@blokkli/editor 2.0.0-alpha.4 → 2.0.0-alpha.40

package/dist/modules/drupal/runtime/adapter/index.js

@@ -1,6 +1,9 @@
-import { defineBlokkliEditAdapter } from "#blokkli/adapter";
+import {
+  defineBlokkliEditAdapter
+} from "#blokkli/editor/adapter";
 import { falsy } from "#blokkli/helpers";
 import { availableFeaturesAtBuild } from "#blokkli-build/features";
+import { templateEditRouteName } from "#blokkli-build/drupal-config";
 import { operationSources } from "#nuxt-graphql-middleware/sources";
 import {
   useGraphqlQuery,
@@ -10,8 +13,106 @@ import {
   useRouter
 } from "#imports";
 import { ParagraphsBlokkliRemoteVideoProvider } from "#graphql-operations";
+function mapPublishOptions(publishOptions) {
+  return {
+    canPublish: !!publishOptions.canPublish,
+    isRevisionable: !!publishOptions.isRevisionable,
+    hasRevisionLogMessage: !!publishOptions.hasRevisionLogMessage,
+    lastChanged: publishOptions.lastChanged ?? null,
+    canSchedule: !!publishOptions.canSchedule,
+    publishOn: publishOptions.publishOn ?? null,
+    revisionLogMessage: publishOptions.revisionLogMessage ?? null
+  };
+}
+const PERMISSION_FIELDS = {
+  use_blokkli: "use_blokkli",
+  take_ownership: "take_ownership",
+  manage_default_templates: "manage_default_templates",
+  create_library_item: "create_library_item",
+  edit_library_item: "edit_library_item",
+  create_comments: "create_comments",
+  view_comments: "view_comments",
+  use_agent: "use_agent"
+};
+function mapUserPermissions(user) {
+  return Object.entries(PERMISSION_FIELDS).filter(([, field]) => user[field] === true).map(([permission]) => permission);
+}
+function valueToFilterString(v) {
+  if (typeof v === "string") {
+    return v;
+  } else if (typeof v === "number") {
+    return v.toString();
+  } else if (typeof v === "boolean") {
+    return v ? "1" : "0";
+  }
+  return "";
+}
+function configObjectToUserConfigInput(values) {
+  if (!values) {
+    return [];
+  }
+  return Object.entries(values).map(([name, value]) => {
+    return {
+      name,
+      value: valueToFilterString(value)
+    };
+  });
+}
+function mapPluginConfigInputs(inputs) {
+  return inputs.map((input) => {
+    if (input.__typename === "ParagraphsBlokkliConfigInputText") {
+      return {
+        type: "text",
+        name: input.name,
+        label: input.label,
+        description: input.description,
+        required: input.required,
+        defaultValue: input.defaultValueText,
+        minLength: input.minLength,
+        maxLength: input.maxLength,
+        placeholder: input.placeholder,
+        pattern: input.pattern,
+        multiline: input.multiline,
+        rows: input.rows
+      };
+    } else if (input.__typename === "ParagraphsBlokkliConfigInputCheckbox") {
+      return {
+        type: "checkbox",
+        name: input.name,
+        label: input.label,
+        description: input.description,
+        required: input.required,
+        defaultValue: input.defaultValueCheckbox ?? false,
+        checkboxLabel: input.checkboxLabel
+      };
+    } else if (input.__typename === "ParagraphsBlokkliConfigInputOptions") {
+      return {
+        type: "options",
+        name: input.name,
+        label: input.label,
+        description: input.description,
+        required: input.required,
+        defaultValue: input.defaultValueOptions ?? "",
+        variant: input.variant,
+        options: input.options
+      };
+    } else if (input.__typename === "ParagraphsBlokkliConfigInputSeed") {
+      return {
+        type: "seed",
+        name: input.name,
+        label: input.label,
+        description: input.description,
+        required: input.required
+      };
+    }
+    return null;
+  }).filter(falsy);
+}
 export default defineBlokkliEditAdapter(
   async (providedContext) => {
+    if (import.meta.dev) {
+      console.log("initialise Drupal bl\xF6kkli adapter");
+    }
     const availableFeatureIds = new Set(availableFeaturesAtBuild);
     const availableGraphqlOperations = new Set(Object.keys(operationSources));
     function hasQuery(name) {
@@ -34,9 +135,10 @@ export default defineBlokkliEditAdapter(
     }).then((v) => {
       return {
         clipboard: v.data.clipboards || [],
+        userPermissions: v.data.userPermissions,
         availableFeatures: v.data.features,
         allTypes: (v.data.allTypes.items || []).filter(
-          (v2) => v2 && "icon" in v2
+          (v2) => v2 && "id" in v2
         ),
         fieldConfig: v.data.fieldConfig || [],
         editableFieldConfig: v.data.editableFieldConfig || [],
@@ -52,6 +154,14 @@ export default defineBlokkliEditAdapter(
         )
       };
     });
+    const entityConfig = await useGraphqlQuery("pbEntityConfig", {
+      entityType: providedContext.value.entityType,
+      entityUuid: providedContext.value.entityUuid
+    }).then((v) => {
+      return {
+        linkPath: v.data.config?.linkPath ?? ""
+      };
+    });
     const loadState = async () => {
       const state = await useGraphqlQuery("pbEditState", {
         ...ctx.value
@@ -75,6 +185,10 @@ export default defineBlokkliEditAdapter(
       const fields = state?.mutatedState?.fields || [];
       const violations = state.mutatedState?.violations || [];
       const entity = state.entity;
+      if (!state.publishOptions) {
+        throw new Error("Missing publish options.");
+      }
+      const publishOptions = mapPublishOptions(state.publishOptions);
       const mutatedOptions = state.mutatedState?.mutatedOptions || {};
       Object.keys(mutatedOptions).forEach((uuid) => {
         mutatedOptions[uuid] = mutatedOptions[uuid]?.paragraphs_blokkli_data || {};
@@ -101,6 +215,7 @@ export default defineBlokkliEditAdapter(
           return null;
         }).filter(falsy)
       };
+      const mutatedHostOptions = state.mutatedState?.hostOptions || {};
       return {
         currentIndex,
         mutations,
@@ -109,8 +224,11 @@ export default defineBlokkliEditAdapter(
         mutatedState: {
           fields,
           violations,
-          mutatedOptions
+          mutatedOptions,
+          // PHP and its arrays...
+          mutatedHostOptions: Array.isArray(mutatedHostOptions) ? {} : mutatedHostOptions
         },
+        publishOptions,
         entity,
         mutatedEntity: state.mutatedEntity,
         translationState
@@ -126,7 +244,7 @@ export default defineBlokkliEditAdapter(
     }).then(mapMutation);
     const moveBlock = (e) => useGraphqlMutation("pbMoveParagraph", {
       ...ctx.value,
-      uuid: e.item.uuid,
+      uuid: e.item.block.uuid,
       hostType: e.host.type,
       hostUuid: e.host.uuid,
       hostFieldName: e.host.fieldName,
@@ -162,7 +280,14 @@ export default defineBlokkliEditAdapter(
       }
       return Promise.resolve(disabled);
     };
-    const mapMutation = (v) => v.data?.state?.action;
+    const mapMutation = (v) => {
+      const action = v.data?.state?.action;
+      return {
+        success: !!action?.success,
+        state: action?.state,
+        errors: (action?.errors ?? []).filter(falsy)
+      };
+    };
     const route = useRoute();
     const router = useRouter();
     const changeLanguage = (translation) => {
@@ -233,9 +358,16 @@ export default defineBlokkliEditAdapter(
     const getLastChanged = () => $fetch(
       `/paragraphs_blokkli/${ctx.value.entityType}/${ctx.value.entityUuid}/last_changed`
     ).then((v) => v.changed);
+    const buildAnchorLink = (id, _uuid) => {
+      return `${entityConfig.linkPath}#${id}`;
+    };
     const adapter = {
       addNewBlock,
       buildEditableFrameUrl,
+      getUserPermissions: function() {
+        const permissions = config.userPermissions ? mapUserPermissions(config.userPermissions) : [];
+        return Promise.resolve(permissions);
+      },
       changeLanguage,
       formFrameBuilder,
       getAllBundles,
@@ -248,7 +380,8 @@ export default defineBlokkliEditAdapter(
       loadStateAtIndex,
       mapState,
       moveBlock,
-      moveMultipleBlocks
+      moveMultipleBlocks,
+      buildAnchorLink
     };
     if (hasQuery("pbPublishOptions")) {
       adapter.getPublishOptions = () => useGraphqlQuery("pbPublishOptions", ctx.value).then((v) => {
@@ -256,22 +389,28 @@ export default defineBlokkliEditAdapter(
         if (!options) {
           throw new Error("Failed to load publish options.");
         }
-        return options;
+        return mapPublishOptions(options);
       });
     }
     if (hasQuery("pbGetImportSourceEntities")) {
-      adapter.getImportItems = (searchText) => useGraphqlQuery("pbGetImportSourceEntities", {
+      adapter.getImportItems = (args) => useGraphqlQuery("pbGetImportSourceEntities", {
         entityType: ctx.value.entityType.toLowerCase(),
         entityUuid: ctx.value.entityUuid,
-        searchText
+        page: args.page,
+        filters: configObjectToUserConfigInput(args.filters)
       }).then((data) => {
         return {
+          perPage: data.data.pbGetImportSourceEntities?.perPage ?? 16,
           total: data?.data.pbGetImportSourceEntities?.total || 0,
+          filters: mapPluginConfigInputs(
+            data.data.pbGetImportSourceEntities?.filters ?? []
+          ),
           items: (data?.data.pbGetImportSourceEntities?.items || []).map((item) => {
             if (item?.uuid) {
               return {
                 uuid: item.uuid,
-                label: item.label || item.uuid
+                label: item.label,
+                description: item.description
               };
             }
           }).filter(falsy)
@@ -286,6 +425,12 @@ export default defineBlokkliEditAdapter(
     if (hasMutation("pbTakeOwnership")) {
       adapter.takeOwnership = () => useGraphqlMutation("pbTakeOwnership", ctx.value).then(mapMutation);
     }
+    if (hasMutation("pbUpdateHostOptions")) {
+      adapter.updateHostOptions = (items) => useGraphqlMutation("pbUpdateHostOptions", {
+        ...ctx.value,
+        items
+      }).then(mapMutation);
+    }
     if (hasMutation("pbSetHistoryIndex")) {
       adapter.setHistoryIndex = (index) => useGraphqlMutation("pbSetHistoryIndex", {
         ...ctx.value,
@@ -304,7 +449,6 @@ export default defineBlokkliEditAdapter(
         entityType: options.hostEntityType.toUpperCase(),
         entityUuid: options.hostEntityUuid,
         createNewState: !options.closeAfterPublish,
-        // @ts-expect-error Might not exist.
         publishIfUnpublished: options.publishIfUnpublished,
         revisionLogMessage: options.revisionLogMessage
       }).then(mapMutation);
@@ -438,19 +582,19 @@ export default defineBlokkliEditAdapter(
         ...ctx.value,
         blockUuids,
         body
-      }).then((v) => mapComments(v.data.state?.action || []));
+      }).then((v) => mapComments(v.data.action || []));
     }
     if (hasMutation("pbResolveComment")) {
       adapter.resolveComment = (uuid) => useGraphqlMutation("pbResolveComment", {
         ...ctx.value,
         uuid
-      }).then((v) => mapComments(v.data.state?.action || []));
+      }).then((v) => mapComments(v.data.action || []));
     }
     if (hasQuery("pbLibraryItems")) {
       adapter.getLibraryItems = (data) => {
         return useGraphqlQuery("pbLibraryItems", {
           bundles: data.bundles,
-          text: data.text,
+          filters: configObjectToUserConfigInput(data.filters),
           page: data.page
         }).then((response) => {
           const items = response.data.result?.items?.map((v) => {
@@ -471,7 +615,8 @@ export default defineBlokkliEditAdapter(
           return {
             items,
             perPage: response.data.result?.perPage || 16,
-            total: response.data.result?.total || 0
+            total: response.data.result?.total || 0,
+            filters: mapPluginConfigInputs(response.data.result?.filters ?? [])
           };
         });
       };
@@ -487,10 +632,26 @@ export default defineBlokkliEditAdapter(
           return {
             id: plugin.id,
             label: plugin.label,
+            description: plugin.description,
             bundles: plugin.bundles,
             targetBundles: plugin.targetBundles,
             min: plugin.min,
-            max: plugin.max
+            max: plugin.max,
+            configInputs: mapPluginConfigInputs(plugin.configInputs),
+            preview: plugin.allowPreview
+          };
+        })
+      );
+    }
+    if (hasQuery("pbGetHostTransformPlugins")) {
+      adapter.getHostTransformPlugins = () => useGraphqlQuery("pbGetHostTransformPlugins", ctx.value).then((v) => v.data.paragraphsBlokkliGetHostTransformPlugins || []).then(
+        (plugins) => plugins.map((plugin) => {
+          return {
+            id: plugin.id,
+            label: plugin.label,
+            description: plugin.description,
+            configInputs: mapPluginConfigInputs(plugin.configInputs),
+            preview: plugin.allowPreview
           };
         })
       );
@@ -500,6 +661,22 @@ export default defineBlokkliEditAdapter(
         ...ctx.value,
         ...e
       }).then(mapMutation);
+      adapter.previewTransformPlugin = (e) => useGraphqlMutation("pbApplyTransformPlugin", {
+        ...ctx.value,
+        ...e,
+        preview: true
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbApplyHostTransformPlugin")) {
+      adapter.applyHostTransformPlugin = (e) => useGraphqlMutation("pbApplyHostTransformPlugin", {
+        ...ctx.value,
+        ...e
+      }).then(mapMutation);
+      adapter.previewHostTransformPlugin = (e) => useGraphqlMutation("pbApplyHostTransformPlugin", {
+        ...ctx.value,
+        ...e,
+        preview: true
+      }).then(mapMutation);
     }
     const buildFormUrl = (parts, langcode) => {
       const prefix = config.urlPrefixes[langcode];
@@ -527,14 +704,18 @@ export default defineBlokkliEditAdapter(
       }).then(mapMutation);
     }
     if (hasMutation("pbAddFragmentParagraph")) {
-      adapter.fragmentsAddBlock = (e) => useGraphqlMutation("pbAddFragmentParagraph", {
-        ...ctx.value,
-        hostType: e.host.type,
-        hostFieldName: e.host.fieldName,
-        hostUuid: e.host.uuid,
-        afterUuid: e.preceedingUuid,
-        name: e.name
-      }).then(mapMutation);
+      adapter.fragmentsAddBlock = (e) => {
+        const options = e.options ? JSON.stringify(e.options) : void 0;
+        return useGraphqlMutation("pbAddFragmentParagraph", {
+          ...ctx.value,
+          hostType: e.host.type,
+          hostFieldName: e.host.fieldName,
+          hostUuid: e.host.uuid,
+          afterUuid: e.preceedingUuid,
+          name: e.name,
+          options
+        }).then(mapMutation);
+      };
     }
     if (hasMutation("pbReplaceMedia")) {
       adapter.mediaLibraryReplaceMedia = (e) => useGraphqlMutation("pbReplaceMedia", {
@@ -561,28 +742,13 @@ export default defineBlokkliEditAdapter(
     if (hasQuery("pbMediaLibraryGetResults")) {
       adapter.mediaLibraryGetResults = (e) => {
         return useGraphqlQuery("pbMediaLibraryGetResults", {
-          text: e.filters.text,
-          bundle: e.filters.bundle,
+          filters: configObjectToUserConfigInput(e.filters),
           page: e.page
         }).then((data) => {
           return {
-            filters: (data.data.pbMediaLibraryGetResults?.filters || []).reduce((acc, filter) => {
-              if (filter?.__typename === "ParagraphsBlokkliMediaLibraryFilterText") {
-                acc[filter.id] = {
-                  type: "text",
-                  placeholder: filter.placeholder,
-                  label: filter.label
-                };
-              } else if (filter?.__typename === "ParagraphsBlokkliMediaLibraryFilterSelect") {
-                acc[filter.id] = {
-                  type: "select",
-                  label: filter.label,
-                  default: filter.default,
-                  options: filter.options
-                };
-              }
-              return acc;
-            }, {}),
+            filters: mapPluginConfigInputs(
+              data.data.pbMediaLibraryGetResults?.filters ?? []
+            ),
             items: (data.data.pbMediaLibraryGetResults?.items || []).filter(
               falsy
             ),
@@ -599,7 +765,7 @@ export default defineBlokkliEditAdapter(
           targetId: e.item.mediaId,
           targetBundle: e.item.mediaBundle,
           targetType: "media",
-          paragraphBundle: e.item.itemBundle,
+          paragraphBundle: e.targetBundle,
           hostType: e.host.type,
           hostUuid: e.host.uuid,
           hostFieldName: e.host.fieldName,
@@ -616,7 +782,7 @@ export default defineBlokkliEditAdapter(
               targetId: item.mediaId,
               targetType: "media",
               targetBundle: item.mediaBundle,
-              paragraphBundle: item.itemBundle
+              paragraphBundle: e.targetBundle
             };
           }),
           hostType: e.host.type,
@@ -629,15 +795,20 @@ export default defineBlokkliEditAdapter(
     if (hasQuery("pbSearchTabs")) {
       adapter.getContentSearchTabs = () => {
         return useGraphqlQuery("pbSearchTabs").then((v) => {
-          return (v.data.tabs || []).reduce(
-            (acc, tab) => {
-              if (tab?.id) {
-                acc[tab.id] = tab.label;
-              }
-              return acc;
-            },
-            {}
-          );
+          return (v.data.tabs ?? []).map((tab) => {
+            if (!tab) {
+              return null;
+            }
+            return {
+              id: tab.id,
+              title: tab.label,
+              description: tab.description ?? null,
+              types: tab.types.map((t) => ({
+                type: t.entityType,
+                bundles: t.bundles
+              }))
+            };
+          }).filter(falsy);
         });
       };
     }
@@ -664,7 +835,7 @@ export default defineBlokkliEditAdapter(
         }).then(mapMutation);
       };
     }
-    if (availableFeatureIds.has("comments")) {
+    if (availableFeatureIds.has("clipboard")) {
       adapter.clipboardMapBundle = (e) => {
         if (e.type === "video") {
           return config.clipboard.find((v) => {
@@ -681,19 +852,19 @@ export default defineBlokkliEditAdapter(
               }
             }
             return false;
-          })?.possibleParagraphBundles?.[0];
+          })?.possibleParagraphBundles;
         } else if (e.type === "plaintext") {
           return config.clipboard.find((v) => {
             return v?.__typename === "ParagraphsBlokkliSupportedClipboardRichText";
-          })?.possibleParagraphBundles?.[0];
+          })?.possibleParagraphBundles;
         } else if (e.type === "image") {
           return config.clipboard.find((v) => {
             return v?.__typename === "ParagraphsBlokkliSupportedClipboardImage";
-          })?.possibleParagraphBundles?.[0];
+          })?.possibleParagraphBundles;
         } else if (e.type === "file") {
           return config.clipboard.find((v) => {
             return v?.__typename === "ParagraphsBlokkliSupportedClipboardFile";
-          })?.possibleParagraphBundles?.[0];
+          })?.possibleParagraphBundles;
         }
       };
     }
@@ -755,11 +926,266 @@ export default defineBlokkliEditAdapter(
               return null;
             }).filter(falsy),
             total: data.data.pbSearchEditStates?.total || 0,
-            perPage: data.data.pbSearchEditStates?.perPage || 0
+            perPage: data.data.pbSearchEditStates?.perPage || 0,
+            filters: mapPluginConfigInputs(
+              data.data.pbSearchEditStates?.filters ?? []
+            )
+          };
+        });
+      };
+    }
+    if (hasQuery("pbSearchTemplates")) {
+      adapter.templatesSearch = (e) => {
+        return useGraphqlQuery("pbSearchTemplates", {
+          filters: configObjectToUserConfigInput(e.filters),
+          page: e.page,
+          includeItems: e.includeItems
+        }).then((data) => {
+          return {
+            filters: mapPluginConfigInputs(data.data.results?.filters ?? []),
+            items: (data.data.results?.items || []).filter(falsy).map((v) => {
+              const permissions = [];
+              if (v.blokkliMetadata.canDelete) {
+                permissions.push("delete");
+              }
+              if (v.blokkliMetadata.canEdit) {
+                permissions.push("edit");
+              }
+              return {
+                uuid: v.uuid,
+                label: v.label ?? "",
+                description: v.description,
+                isDefault: !!v.isDefault,
+                itemBundles: v.templateBundles,
+                items: (v.items ?? []).filter(falsy),
+                permissions,
+                translationLanguages: v.translationLanguages,
+                metadata: {
+                  description: v.description ?? null,
+                  createdBy: v.blokkliMetadata.createdBy ?? null,
+                  dateUpdated: v.blokkliMetadata.dateUpdated ?? null,
+                  dateCreated: v.blokkliMetadata.dateCreated ?? null
+                }
+              };
+            }),
+            total: data.data.results?.total || 0,
+            perPage: data.data.results?.perPage || 50
+          };
+        });
+      };
+    }
+    if (hasMutation("pbAddTemplate")) {
+      adapter.templatesAdd = (e) => {
+        return useGraphqlMutation("pbAddTemplate", {
+          ...ctx.value,
+          templateUuid: e.templateUuid,
+          hostType: e.host.type,
+          hostUuid: e.host.uuid,
+          hostFieldName: e.host.fieldName,
+          afterUuid: e.afterUuid
+        }).then(mapMutation);
+      };
+    }
+    if (hasMutation("pbTemplateDelete")) {
+      adapter.templatesDelete = (e) => {
+        return useGraphqlMutation("pbTemplateDelete", {
+          uuid: e.templateUuid
+        }).then((v) => {
+          return {
+            success: !!v.data.action.success,
+            state: v.data.action.state,
+            errors: (v.data.action.errors ?? []).filter(falsy)
           };
         });
       };
     }
+    if (hasMutation("pbCreateTemplate")) {
+      adapter.templatesCreate = (e) => {
+        return useGraphqlMutation("pbCreateTemplate", {
+          ...ctx.value,
+          label: e.label,
+          description: e.description,
+          isDefault: e.isDefault,
+          uuids: e.uuids
+        }).then(mapMutation);
+      };
+    }
+    if (hasQuery("pbGetTemplateEntity") && templateEditRouteName) {
+      try {
+        const href = router.resolve({
+          name: templateEditRouteName,
+          params: {
+            uuid: "UUID_PLACEHOLDER"
+          }
+        }).path;
+        adapter.templatesGetEditUrl = (e) => {
+          return href.replace("UUID_PLACEHOLDER", e.templateUuid) + "?blokkliEditing=" + e.templateUuid;
+        };
+      } catch {
+        console.error(
+          `The provided templateEditRouteName "${templateEditRouteName}" is not valid. Editing templates will not be possible.`
+        );
+      }
+    }
+    if (hasMutation("pbUnschedule")) {
+      adapter.unscheduleEditState = (options) => useGraphqlMutation("pbUnschedule", {
+        entityType: options.hostEntityType.toUpperCase(),
+        entityUuid: options.hostEntityUuid
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbSchedule")) {
+      adapter.scheduleEditState = (options) => useGraphqlMutation("pbSchedule", {
+        entityType: options.hostEntityType.toUpperCase(),
+        entityUuid: options.hostEntityUuid,
+        date: options.date,
+        revisionLogMessage: options.revisionLogMessage
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbSetParagraphSchedule")) {
+      adapter.setBlockScheduleDate = (blocks) => useGraphqlMutation("pbSetParagraphSchedule", {
+        entityType: ctx.value.entityType,
+        entityUuid: ctx.value.entityUuid,
+        langcode: ctx.value.langcode,
+        items: blocks
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbSwapParagraphs")) {
+      adapter.swapBlocks = (uuid1, uuid2) => useGraphqlMutation("pbSwapParagraphs", {
+        entityType: ctx.value.entityType,
+        entityUuid: ctx.value.entityUuid,
+        langcode: ctx.value.langcode,
+        uuid1,
+        uuid2
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbReplaceEntityReference")) {
+      adapter.replaceContentSearchItem = (data) => useGraphqlMutation("pbReplaceEntityReference", {
+        entityType: ctx.value.entityType,
+        entityUuid: ctx.value.entityUuid,
+        langcode: ctx.value.langcode,
+        targetType: data.item.entityType,
+        targetBundle: data.item.entityBundle,
+        targetId: data.item.id,
+        uuid: data.host.uuid
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbAddMultipleParagraphs")) {
+      const mapBlockToGraphQL = (block) => {
+        const values = {};
+        for (const entry of block.values ?? []) {
+          const droppableConfig = config.droppableFieldConfig.find(
+            (f) => f.entityBundle === block.bundle && f.name === entry.fieldName
+          );
+          if (droppableConfig) {
+            if (droppableConfig.type === "reference") {
+              if (typeof entry.fieldValue !== "string") {
+                values[entry.fieldName] = {
+                  target_id: entry.fieldValue.entityId
+                };
+              }
+            } else if (droppableConfig.type === "link") {
+              if (typeof entry.fieldValue === "string") {
+                values[entry.fieldName] = entry.fieldValue;
+              } else {
+                values[entry.fieldName] = `entity:${entry.fieldValue.entityType}/${entry.fieldValue.entityId}`;
+              }
+            }
+          } else if (typeof entry.fieldValue === "string") {
+            values[entry.fieldName] = entry.fieldValue;
+          }
+        }
+        return {
+          bundle: block.bundle,
+          uuid: block.blockUuid,
+          values,
+          options: block.options,
+          children: block.children ? Object.entries(block.children).map(
+            ([fieldName, childBlocks]) => ({
+              fieldName,
+              items: childBlocks.map(mapBlockToGraphQL)
+            })
+          ) : void 0
+        };
+      };
+      adapter.addNewBlocks = (data) => useGraphqlMutation("pbAddMultipleParagraphs", {
+        entityType: ctx.value.entityType,
+        entityUuid: ctx.value.entityUuid,
+        langcode: ctx.value.langcode,
+        hostType: data.host.type,
+        hostUuid: data.host.uuid,
+        hostFieldName: data.host.fieldName,
+        afterUuid: data.afterUuid,
+        items: data.blocks.map(mapBlockToGraphQL)
+      }).then(mapMutation);
+    }
+    if (hasMutation("paragraphsBlokkliAgentToken")) {
+      adapter.getAgentAuthToken = function() {
+        return useGraphqlMutation("paragraphsBlokkliAgentToken").then(
+          (v) => v.data.token ?? null
+        );
+      };
+    }
+    if (hasMutation("pbAgentConversationUpsert") && hasMutation("pbAgentConversationDelete") && hasQuery("pbAgentConversations") && hasQuery("pbAgentConversation")) {
+      const hostParams = () => ({
+        hostEntityType: providedContext.value.entityType,
+        hostEntityUuid: providedContext.value.entityUuid
+      });
+      adapter.agentConversations = {
+        upsert: (data) => useGraphqlMutation("pbAgentConversationUpsert", {
+          ...hostParams(),
+          uuid: data.uuid,
+          title: data.title,
+          dataUser: data.clientState,
+          dataServer: data.serverState,
+          hash: data.hash
+        }).then((v) => v.data.result.success),
+        load: (uuid) => useGraphqlQuery("pbAgentConversation", {
+          ...hostParams(),
+          uuid
+        }).then((v) => v.data.conversation ?? null),
+        loadLatest: () => useGraphqlQuery("pbAgentConversation", hostParams()).then(
+          (v) => v.data.conversation ?? null
+        ),
+        list: () => useGraphqlQuery("pbAgentConversations", hostParams()).then(
+          (v) => v.data.conversations
+        ),
+        delete: (uuid) => useGraphqlMutation("pbAgentConversationDelete", { uuid }).then(
+          (v) => v.data.result.success
+        )
+      };
+    }
+    if (hasMutation("pbBulkUpdateFieldValues")) {
+      adapter.updateFieldValueBatched = (data) => {
+        const entityItems = data.entityItems.map((item) => {
+          return {
+            name: item.fieldName,
+            value: item.fieldValue
+          };
+        });
+        const blockItems = data.items.map((item) => {
+          return {
+            uuid: item.uuid,
+            name: item.fieldName,
+            value: item.fieldValue
+          };
+        });
+        return useGraphqlMutation("pbBulkUpdateFieldValues", {
+          ...ctx.value,
+          items: [...entityItems, ...blockItems]
+        }).then(mapMutation);
+      };
+    }
+    if (hasMutation("pbRearrangeParagraphs")) {
+      adapter.rearrangeBlocks = (data) => {
+        return useGraphqlMutation("pbRearrangeParagraphs", {
+          ...ctx.value,
+          hostType: data.host.type,
+          hostFieldName: data.host.fieldName,
+          hostUuid: data.host.uuid,
+          uuids: data.uuids
+        }).then(mapMutation);
+      };
+    }
     return adapter;
   }
 );