@webiny/mcp 6.3.0-beta.1 → 6.3.0-beta.3

package/skills/admin/website-builder/page-settings/SKILL.md

@@ -0,0 +1,216 @@
+---
+name: webiny-page-settings-extensions
+context: webiny-extensions
+description: >
+  Extending the Website Builder page settings with custom settings groups and modifiers.
+  Use this skill when the developer wants to add a new tab/group to the page settings
+  drawer (e.g., Publishing, Analytics, Access Control), or modify an existing settings
+  group (e.g., add fields to General or SEO). Covers PageSettingsGroup, PageSettingsGroupModifier,
+  and the doc.extensions data model. For field types, renderers, and layout details,
+  see the webiny-form-model skill.
+---
+
+# Page Settings Extensions
+
+## TL;DR
+
+Page settings extensions let you add new tabs to the page settings drawer or inject fields into existing tabs. Create a class implementing `PageSettingsGroup.Interface` for a new tab, or `PageSettingsGroupModifier.Interface` to extend an existing one. Register both via `createFeature()` and `<RegisterFeature>`. **Always store custom data in `doc.extensions` — never write to `doc.properties`, which is reserved for built-in system properties.**
+
+**YOU MUST include the full file path with the `.tsx` extension in every `src` prop.** For example, use `src={"/extensions/myPageSettings/index.tsx"}`, NOT `src={"/extensions/myPageSettings/index"}`. Omitting the file extension will cause a build failure.
+
+For field types, renderers, layout, validation, and all other form builder APIs, refer to the **webiny-form-model** skill.
+
+## Important: Where to Store Data
+
+> **Use `doc.extensions` for all custom data.** The `doc.properties` object holds built-in system properties (title, path, snippet, image, tags, seo, social). Writing custom fields into `doc.properties` risks naming collisions with future Webiny updates and can corrupt system behavior. Always namespace your data under `doc.extensions.<yourGroupName>`.
+
+```typescript
+// CORRECT — custom data in doc.extensions
+mapFromForm(formData, doc) {
+    doc.extensions.mySettings = doc.extensions.mySettings ?? {};
+    doc.extensions.mySettings.myField = formData.myField;
+}
+
+// WRONG — never write custom data into doc.properties
+mapFromForm(formData, doc) {
+    doc.properties.myField = formData.myField; // DON'T DO THIS
+}
+```
+
+## Adding a New Settings Group
+
+A new settings group appears as its own tab in the page settings drawer. Implement `PageSettingsGroup.Interface` with these members:
+
+| Member                       | Type                                        | Description                                               |
+| ---------------------------- | ------------------------------------------- | --------------------------------------------------------- |
+| `name`                       | `string`                                    | Unique group identifier (used as form field namespace)    |
+| `label`                      | `string`                                    | Tab label shown in the UI                                 |
+| `description`                | `string` (optional)                         | Description shown below the tab label                     |
+| `icon`                       | `{ type: "icon", name: string }` (optional) | FontAwesome icon for the tab (e.g., `"fas/calendar-alt"`) |
+| `buildForm(form)`            | method                                      | Define fields and layout                                  |
+| `mapToForm(doc)`             | method                                      | Read from document to populate the form                   |
+| `mapFromForm(formData, doc)` | method                                      | Write form values back to the document                    |
+
+### Complete Example: Publishing Settings Group
+
+```typescript
+// extensions/myPageSettings/PublishingSettingsGroup.ts
+import { PageSettingsGroup } from "webiny/admin/website-builder/page/editor";
+
+class PublishingSettingsGroupImpl implements PageSettingsGroup.Interface {
+  name = "publishing";
+  label = "Publishing";
+  description = "Configure publishing schedule and visibility.";
+  icon = { type: "icon", name: "fas/calendar-alt" };
+
+  buildForm(form: PageSettingsGroup.FormBuilder): void {
+    form.fields(fields => ({
+      publishDate: fields.datetime().withTimezone().label("Publish date"),
+      unpublishDate: fields.datetime().dateOnly().label("Unpublish date"),
+      visibility: fields
+        .text()
+        .label("Visibility")
+        .options([
+          { label: "Public", value: "public" },
+          { label: "Private", value: "private" },
+          { label: "Password Protected", value: "password" }
+        ])
+        .defaultValue("public"),
+      featured: fields.boolean().label("Featured page")
+    }));
+
+    form.layout(layout => [
+      layout.row("publishDate"),
+      layout.row("unpublishDate"),
+      layout.row("visibility"),
+      layout.row("featured")
+    ]);
+  }
+
+  mapToForm(doc: PageSettingsGroup.PageDocument): Record<string, any> {
+    const publishing = doc.extensions?.publishing;
+    return {
+      publishDate: publishing?.publishDate ?? null,
+      unpublishDate: publishing?.unpublishDate ?? null,
+      visibility: publishing?.visibility ?? "public",
+      featured: publishing?.featured ?? false
+    };
+  }
+
+  mapFromForm(formData: Record<string, any>, doc: PageSettingsGroup.PageDocument): void {
+    doc.extensions.publishing = doc.extensions.publishing ?? {};
+    doc.extensions.publishing.publishDate = formData.publishDate;
+    doc.extensions.publishing.unpublishDate = formData.unpublishDate;
+    doc.extensions.publishing.visibility = formData.visibility;
+    doc.extensions.publishing.featured = formData.featured;
+  }
+}
+
+export const PublishingSettingsGroup = PageSettingsGroup.createImplementation({
+  implementation: PublishingSettingsGroupImpl,
+  dependencies: []
+});
+```
+
+## Modifying an Existing Settings Group
+
+A modifier injects fields into an existing tab without subclassing it. Implement `PageSettingsGroupModifier.Interface`:
+
+| Member                       | Type              | Description                                                             |
+| ---------------------------- | ----------------- | ----------------------------------------------------------------------- |
+| `group`                      | `string`          | Name of the target group (`"general"`, `"seo"`, `"social"`, `"schema"`) |
+| `modifyForm(form)`           | method            | Add fields and layout entries to the existing group                     |
+| `mapToForm(doc)`             | method (optional) | Supply values for the new fields                                        |
+| `mapFromForm(formData, doc)` | method (optional) | Persist the new field values                                            |
+
+### Complete Example: Add Expiration Date to the General Tab
+
+```typescript
+// extensions/myPageSettings/GeneralSettingsModifier.ts
+import { PageSettingsGroupModifier } from "webiny/admin/website-builder/page/editor";
+
+class GeneralSettingsModifierImpl implements PageSettingsGroupModifier.Interface {
+  group = "general";
+
+  modifyForm(form: PageSettingsGroupModifier.FormBuilder): void {
+    form.fields(fields => ({
+      expirationDate: fields.datetime().monthOnly().label("Expiration month")
+    }));
+
+    // .after("snippet") places the field after the "snippet" field in the General tab
+    form.layout(layout => [layout.row("expirationDate").after("snippet")]);
+  }
+
+  mapToForm(doc: PageSettingsGroupModifier.PageDocument): Record<string, any> {
+    return {
+      expirationDate: doc.extensions?.expirationDate ?? null
+    };
+  }
+
+  mapFromForm(formData: Record<string, any>, doc: PageSettingsGroupModifier.PageDocument): void {
+    doc.extensions.expirationDate = formData.expirationDate;
+  }
+}
+
+export const GeneralSettingsModifier = PageSettingsGroupModifier.createImplementation({
+  implementation: GeneralSettingsModifierImpl,
+  dependencies: []
+});
+```
+
+## Feature Registration
+
+Wrap your group and/or modifier in a feature and export a React component:
+
+```tsx
+// extensions/myPageSettings/index.tsx
+import React from "react";
+import { createFeature, RegisterFeature } from "webiny/admin";
+import { PublishingSettingsGroup } from "./PublishingSettingsGroup.js";
+import { GeneralSettingsModifier } from "./GeneralSettingsModifier.js";
+
+const MyPageSettingsFeature = createFeature({
+  name: "MyPageSettings",
+  register(container) {
+    container.register(PublishingSettingsGroup);
+    container.register(GeneralSettingsModifier);
+  }
+});
+
+export default () => {
+  return <RegisterFeature feature={MyPageSettingsFeature} />;
+};
+```
+
+Register in `webiny.config.tsx`:
+
+```tsx
+<Admin.Extension src={"/extensions/myPageSettings/index.tsx"} />
+```
+
+## Layout Positioning in Modifiers
+
+When modifying an existing group, use `.after("existingFieldName")` to position your new fields relative to built-in fields. The built-in field names for each group:
+
+- **general**: `title`, `path`, `snippet`, `image`, `tags`
+- **seo**: `title`, `description`, `metaTags`, `canonicalUrl`, `noIndex`, `noFollow`
+- **social**: `title`, `description`, `image`, `metaTags`
+- **schema**: `structuredSchema`
+
+## The Page Document Model
+
+The `doc` parameter in `mapToForm` / `mapFromForm` has three top-level namespaces:
+
+```typescript
+interface IPageDocument {
+    properties: { ... };   // SYSTEM — title, path, snippet, seo, social, etc.
+    metadata: { ... };     // SYSTEM — document metadata
+    extensions: { ... };   // YOUR DATA — use this for all custom fields
+}
+```
+
+**Reminder**: `doc.properties` and `doc.metadata` are managed by the system. Always read/write your custom data via `doc.extensions`. Namespace it under your group name to avoid collisions with other extensions (e.g., `doc.extensions.publishing`, `doc.extensions.analytics`).
+
+## Related Skills
+
+- **webiny-form-model** — Field types, renderers, layout, validation, conditional rules, computed fields, and dynamic zones

package/skills/api/v5-to-v6-migration/SKILL.md

@@ -48,7 +48,7 @@ new ContextPlugin(async context => {
 
 ```typescript
 // features/lingotekService/abstractions.ts
-import { createAbstraction } from "@webiny/feature/api";
+import { createAbstraction } from "webiny/api";
 
 export interface ILingotekService {
   translate(docId: string, locale: string): Promise<Result<void, Error>>;
@@ -349,22 +349,22 @@ cat node_modules/@webiny/api-core/features/security/roles/shared/abstractions.d.
 
 ### Backend: Plugin Classes → v6 Equivalents
 
-| v5 Plugin                                       | v6 Equivalent                 |
-| ----------------------------------------------- | ----------------------------- |
-| `ContextPlugin`                                 | DI-registered implementations |
-| `createContextPlugin`                           | DI-registered implementations |
-| `CmsModelPlugin`                                | `ModelFactory`                |
-| `GraphQLSchemaPlugin`                           | `GraphQLSchemaFactory`        |
-| `createGraphQLSchemaPlugin`                     | `GraphQLSchemaFactory`        |
-| `createTaskDefinition`                          | `TaskDefinition`              |
-| `CmsModelFieldToGraphQLPlugin`                  | TODO                          |
-| `createSecurityRolePlugin`                      | `RoleFactory`                 |
-| `createSecurityTeamPlugin`                      | `TeamFactory`                 |
-| `StorageTransformPlugin`                        | TODO                          |
-| `createApiGatewayRoute`                         | TODO (Adrian)                 |
-| `CmsModelFieldValidatorPlugin`                  | TODO                          |
-| `createCmsGraphQLSchemaSorterPlugin`            | TODO                          |
-| `createCmsEntryElasticsearchBodyModifierPlugin` | TODO                          |
+| v5 Plugin                                       | v6 Equivalent                                                                        |
+| ----------------------------------------------- | ------------------------------------------------------------------------------------ |
+| `ContextPlugin`                                 | DI-registered implementations                                                        |
+| `createContextPlugin`                           | DI-registered implementations                                                        |
+| `CmsModelPlugin`                                | `ModelFactory`                                                                       |
+| `GraphQLSchemaPlugin`                           | `GraphQLSchemaFactory`                                                               |
+| `createGraphQLSchemaPlugin`                     | `GraphQLSchemaFactory`                                                               |
+| `createTaskDefinition`                          | `TaskDefinition`                                                                     |
+| `CmsModelFieldToGraphQLPlugin`                  | `CmsModelFieldToGraphQL`                                                             |
+| `createSecurityRolePlugin`                      | `RoleFactory`                                                                        |
+| `createSecurityTeamPlugin`                      | `TeamFactory`                                                                        |
+| `StorageTransformPlugin`                        | `StorageTransform`                                                                   |
+| `createApiGatewayRoute`                         | `Api.Route` (`webiny.config.tsx`) and `Route.Interface` (imported from `webiny/api`) |
+| `CmsModelFieldValidatorPlugin`                  | `CmsModelFieldValidator`                                                             |
+| `createCmsGraphQLSchemaSorterPlugin`            | `CmsGraphQLSchemaSorter`                                                             |
+| `createCmsEntryElasticsearchBodyModifierPlugin` | `CmsEntryOpenSearchBodyModifier`                                                     |
 
 ### Admin: React Plugins → AdminConfig API
 
@@ -374,7 +374,7 @@ cat node_modules/@webiny/api-core/features/security/roles/shared/abstractions.d.
 | `RoutePlugin`                      | `<AdminConfig.Route/>`                                   |
 | `AddMenu` / menu components        | `<AdminConfig.Menu/>`                                    |
 | `HasPermission`                    | `HasPermission` or `createHasPermission` with new schema |
-| `GraphQLPlaygroundTabPlugin`       | TODO                                                     |
+| `GraphQLPlaygroundTabPlugin`       | Not migratable.                                          |
 | `CmsModelFieldTypePlugin`          | `<CmsModelFieldType/>`                                   |
 | `CmsModelFieldRendererPlugin`      | `<CmsModelFieldRenderer/>`                               |
 | `AdminAppPermissionRendererPlugin` | `createPermissionSchema` / `<Security.Permissions/>`     |
@@ -408,6 +408,355 @@ v5: `context.myService = { ... }`. v6: create an abstraction and register it in
 
 v5 habit: putting logic directly in the subscription callback. v6: handlers are thin orchestrators — extract logic into a Service or UseCase.
 
+## Pattern 7: CmsModelFieldToGraphQLPlugin → CmsModelFieldToGraphQL
+
+### v5
+
+```ts
+import { CmsModelFieldToGraphQLPlugin } from "@webiny/api-headless-cms";
+
+new CmsModelFieldToGraphQLPlugin({
+  fieldType: "myField",
+  isSearchable: true,
+  isSortable: false,
+  read: {
+    createTypeField({ field }) {
+      return `${field.fieldId}: String`;
+    },
+    createListFilters({ field }) {
+      return `${field.fieldId}: String`;
+    }
+  },
+  manage: {
+    createTypeField({ field }) {
+      return `${field.fieldId}: String`;
+    },
+    createInputField({ field }) {
+      return `${field.fieldId}: String`;
+    }
+  }
+});
+```
+
+### v6
+
+Import from `webiny/api/cms/graphql.js`. Implement `CmsModelFieldToGraphQL.Interface` — split read/manage into separate classes, export via `CmsModelFieldToGraphQL.createImplementation`, and register in a `createFeature` container.
+
+```ts
+import { createFeature } from "webiny/api";
+import { CmsModelFieldToGraphQL } from "webiny/api/cms/graphql";
+
+class ReadApi implements CmsModelFieldToGraphQL.ReadApi {
+  createTypeField({ field }: CmsModelFieldToGraphQL.TypeFieldParams): string {
+    return `${field.fieldId}: String`;
+  }
+  createListFilters({ field }: CmsModelFieldToGraphQL.ListFiltersParams): string {
+    return `${field.fieldId}: String`;
+  }
+}
+
+class ManageApi implements CmsModelFieldToGraphQL.ManageApi {
+  createTypeField({ field }: CmsModelFieldToGraphQL.TypeFieldParams): string {
+    return `${field.fieldId}: String`;
+  }
+  createInputField({ field }: CmsModelFieldToGraphQL.TypeFieldParams): string {
+    return `${field.fieldId}: String`;
+  }
+}
+
+class MyFieldToGraphQL implements CmsModelFieldToGraphQL.Interface {
+  public readonly fieldType = "myField";
+  public readonly isSearchable = true;
+  public readonly isSortable = false;
+  public readonly isFullTextSearchable = false;
+  public readonly read = new ReadApi();
+  public readonly manage = new ManageApi();
+  getReadApi() {
+    return this.read;
+  }
+  getManageApi() {
+    return this.manage;
+  }
+}
+
+export const MyFieldToGraphQLImplementation = CmsModelFieldToGraphQL.createImplementation({
+  implementation: MyFieldToGraphQL,
+  dependencies: []
+});
+
+export const MyGraphQLFeature = createFeature({
+  name: "MyApp/MyGraphQLFeature",
+  register: container => {
+    container.register(MyFieldToGraphQLImplementation);
+  }
+});
+```
+
+### Looking up a field handler by type
+
+Use `CmsModelFieldToGraphQLRegistry` (also from `webiny/api/cms/graphql.js`) to retrieve any registered field handler by its `fieldType` string. Inject it as a dependency:
+
+```ts
+import { CmsModelFieldToGraphQL } from "webiny/api/cms/graphql";
+import { CmsModelFieldToGraphQLRegistry } from "webiny/api/cms/graphql";
+
+class MyFieldToGraphQL implements CmsModelFieldToGraphQL.Interface {
+  constructor(private readonly registry: CmsModelFieldToGraphQLRegistry.Interface) {}
+
+  // Example: delegate to another field's read API
+  someMethod(fieldType: string) {
+    const handler = this.registry.get(fieldType);
+    // handler is CmsModelFieldToGraphQL.Interface | undefined
+  }
+
+  // ... rest of implementation
+}
+
+export const MyFieldToGraphQLImplementation = CmsModelFieldToGraphQL.createImplementation({
+  implementation: MyFieldToGraphQL,
+  dependencies: [CmsModelFieldToGraphQLRegistry]
+});
+```
+
+`registry.getAll()` returns every registered handler when you need to iterate.
+
+## Pattern 8: createCmsGraphQLSchemaSorterPlugin → CmsGraphQLSchemaSorter
+
+### v5
+
+```ts
+import { createCmsGraphQLSchemaSorterPlugin } from "@webiny/api-headless-cms";
+
+createCmsGraphQLSchemaSorterPlugin({
+  sorter({ model, sorters }) {
+    return [...sorters, `${model.singularApiName}CustomSort_ASC`];
+  }
+});
+```
+
+### v6
+
+```ts
+import { createFeature } from "webiny/api";
+import { CmsGraphQLSchemaSorter } from "webiny/api/cms/graphql";
+
+class MyCustomSorter implements CmsGraphQLSchemaSorter.Interface {
+  execute({ model, sorters }: CmsGraphQLSchemaSorter.Params): string[] {
+    return [...sorters, `${model.singularApiName}CustomSort_ASC`];
+  }
+}
+
+export const MyCustomSorterImplementation = CmsGraphQLSchemaSorter.createImplementation({
+  implementation: MyCustomSorter,
+  dependencies: []
+});
+
+export const MySorterFeature = createFeature({
+  name: "MyApp/MySorterFeature",
+  register: container => {
+    container.register(MyCustomSorterImplementation);
+  }
+});
+```
+
+## Pattern 9: StorageTransformPlugin → StorageTransform
+
+### v5
+
+```ts
+import { StorageTransformPlugin } from "@webiny/api-headless-cms";
+
+new StorageTransformPlugin({
+  fieldType: "myField",
+  async toStorage({ value }) {
+    return serialize(value);
+  },
+  async fromStorage({ value }) {
+    return deserialize(value);
+  }
+});
+```
+
+### v6
+
+Import from `webiny/api/cms/storage.js`. Implement `StorageTransform.Interface` with `toStorage` and `fromStorage` async methods. Register in a `createFeature` container.
+
+```ts
+import { createFeature } from "webiny/api";
+import { StorageTransform } from "webiny/api/cms/storage";
+
+class MyStorageTransform implements StorageTransform.Interface {
+  public readonly fieldType = "myField";
+
+  async toStorage({ value }: StorageTransform.ToStorageParams): Promise<unknown> {
+    return serialize(value);
+  }
+
+  async fromStorage({ value }: StorageTransform.FromStorageParams): Promise<unknown> {
+    return deserialize(value);
+  }
+}
+
+export const MyStorageTransformImpl = StorageTransform.createImplementation({
+  implementation: MyStorageTransform,
+  dependencies: []
+});
+
+export const MyStorageFeature = createFeature({
+  name: "MyApp/MyStorageFeature",
+  register: container => {
+    container.register(MyStorageTransformImpl);
+  }
+});
+```
+
+Use `fieldType: "*"` for a catch-all transform that applies to all field types without a specific handler.
+
+### Looking up a transform by type
+
+Inject `StorageTransformRegistry` (also from `webiny/api/cms/storage.js`) to retrieve any registered transform:
+
+```ts
+import { StorageTransform } from "webiny/api/cms/storage";
+import { StorageTransformRegistry } from "webiny/api/cms/storage";
+
+class MyStorageTransform implements StorageTransform.Interface {
+  constructor(private readonly registry: StorageTransformRegistry.Interface) {}
+
+  async toStorage({ value, field }: StorageTransform.ToStorageParams): Promise<unknown> {
+    const delegate = this.registry.get(field.type);
+    // delegate is StorageTransform.Interface | undefined
+  }
+}
+
+export const MyStorageTransformImpl = StorageTransform.createImplementation({
+  implementation: MyStorageTransform,
+  dependencies: [StorageTransformRegistry]
+});
+```
+
+`registry.getAll()` returns every registered transform when you need to iterate.
+
+## Pattern 10: CmsModelFieldValidatorPlugin → CmsModelFieldValidator
+
+### v5
+
+```ts
+import { CmsModelFieldValidatorPlugin } from "@webiny/api-headless-cms";
+
+new CmsModelFieldValidatorPlugin({
+  validator: {
+    name: "myValidator",
+    async validate({ value, validator }) {
+      if (!meetsCondition(value, validator.settings)) {
+        throw new Error("Validation failed.");
+      }
+    }
+  }
+});
+```
+
+### v6
+
+Import from `webiny/api/cms/validation.js`. Implement `CmsModelFieldValidator.Interface` with a `name` string and an async `validate` method that returns `boolean`. Register in a `createFeature` container.
+
+```ts
+import { createFeature } from "webiny/api";
+import { CmsModelFieldValidator } from "webiny/api/cms/validation";
+
+class MyValidatorImpl implements CmsModelFieldValidator.Interface {
+  public readonly name = "myValidator";
+
+  async validate({ value, validator }: CmsModelFieldValidator.Params): Promise<boolean> {
+    return meetsCondition(value, validator.settings);
+  }
+}
+
+export const MyValidator = CmsModelFieldValidator.createImplementation({
+  implementation: MyValidatorImpl,
+  dependencies: []
+});
+
+export const MyValidationFeature = createFeature({
+  name: "MyApp/MyValidationFeature",
+  register: container => {
+    container.register(MyValidator);
+  }
+});
+```
+
+### Looking up a validator by name
+
+Inject `CmsModelFieldValidatorRegistry` (also from `webiny/api/cms/validation.js`) to retrieve any registered validator:
+
+```ts
+import { CmsModelFieldValidator } from "webiny/api/cms/validation";
+import { CmsModelFieldValidatorRegistry } from "webiny/api/cms/validation";
+
+class MyValidatorImpl implements CmsModelFieldValidator.Interface {
+  constructor(private readonly registry: CmsModelFieldValidatorRegistry.Interface) {}
+
+  async validate({ value, validator }: CmsModelFieldValidator.Params): Promise<boolean> {
+    const delegate = this.registry.get(validator.name);
+    // delegate is CmsModelFieldValidator.Interface | undefined
+    return true;
+  }
+}
+
+export const MyValidator = CmsModelFieldValidator.createImplementation({
+  implementation: MyValidatorImpl,
+  dependencies: [CmsModelFieldValidatorRegistry]
+});
+```
+
+`registry.getAll()` returns every registered validator when you need to iterate.
+
+## Pattern 11: createCmsEntryElasticsearchBodyModifierPlugin → CmsEntryOpenSearchBodyModifier
+
+Note: this abstraction lives in the `api-headless-cms-ddb-es` package (the DynamoDB + OpenSearch storage driver), not `api-headless-cms`. Only register it when that storage driver is in use.
+
+### v5
+
+```ts
+import { createCmsEntryElasticsearchBodyModifierPlugin } from "@webiny/api-headless-cms-ddb-es";
+
+createCmsEntryElasticsearchBodyModifierPlugin({
+  modelId: "myModel", // optional — omit to apply to all models
+  modifyBody({ body, model, where }) {
+    body.query.bool.filter.push({ term: { tenant: where.tenant } });
+  }
+});
+```
+
+### v6
+
+Import from `webiny/api/cms/opensearch.js`. Implement `CmsEntryOpenSearchBodyModifier.Interface` with a synchronous `modifyBody` method. The optional `modelId` property scopes the modifier to a single model; omit it to apply to all models.
+
+```ts
+import { createFeature } from "webiny/api";
+import { CmsEntryOpenSearchBodyModifier } from "webiny/api/cms/opensearch";
+
+class MyBodyModifier implements CmsEntryOpenSearchBodyModifier.Interface {
+  public readonly modelId = "myModel"; // omit to apply to all models
+
+  modifyBody({ body, model, where }: CmsEntryOpenSearchBodyModifier.Params): void {
+    body.query.bool.filter.push({ term: { tenant: where.tenant } });
+  }
+}
+
+export const MyBodyModifierImpl = CmsEntryOpenSearchBodyModifier.createImplementation({
+  implementation: MyBodyModifier,
+  dependencies: []
+});
+
+export const MyOpenSearchFeature = createFeature({
+  name: "MyApp/MyOpenSearchFeature",
+  register: container => {
+    container.register(MyBodyModifierImpl);
+  }
+});
+```
+
 ## Related Skills
 
 - **webiny-api-architect** — Full v6 architecture, Services vs UseCases, anti-patterns