@atlaskit/editor-synced-block-provider 3.30.6 → 3.31.1

package/dist/cjs/store-manager/syncBlockSubscriptionManager.js

@@ -0,0 +1,198 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SyncBlockSubscriptionManager = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _monitoring = require("@atlaskit/editor-common/monitoring");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _errorHandling = require("../utils/errorHandling");
+var _resolveSyncBlockInstance = require("../utils/resolveSyncBlockInstance");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Manages the lifecycle of GraphQL WebSocket subscriptions for sync block
+ * real-time updates, and provides a listener API so React components can
+ * react when the set of subscribed resource IDs changes.
+ */
+var SyncBlockSubscriptionManager = exports.SyncBlockSubscriptionManager = /*#__PURE__*/function () {
+  function SyncBlockSubscriptionManager(deps) {
+    (0, _classCallCheck2.default)(this, SyncBlockSubscriptionManager);
+    (0, _defineProperty2.default)(this, "graphqlSubscriptions", new Map());
+    (0, _defineProperty2.default)(this, "subscriptionChangeListeners", new Set());
+    (0, _defineProperty2.default)(this, "useRealTimeSubscriptions", false);
+    this.deps = deps;
+  }
+  return (0, _createClass2.default)(SyncBlockSubscriptionManager, [{
+    key: "setRealTimeSubscriptionsEnabled",
+    value: function setRealTimeSubscriptionsEnabled(enabled) {
+      if (this.useRealTimeSubscriptions === enabled) {
+        return;
+      }
+      this.useRealTimeSubscriptions = enabled;
+      if (enabled) {
+        this.setupSubscriptionsForAllBlocks();
+      } else {
+        this.cleanupAll();
+      }
+    }
+  }, {
+    key: "isRealTimeSubscriptionsEnabled",
+    value: function isRealTimeSubscriptionsEnabled() {
+      return this.useRealTimeSubscriptions;
+    }
+  }, {
+    key: "getSubscribedResourceIds",
+    value: function getSubscribedResourceIds() {
+      return Array.from(this.deps.getSubscriptions().keys());
+    }
+  }, {
+    key: "onSubscriptionsChanged",
+    value: function onSubscriptionsChanged(listener) {
+      var _this = this;
+      this.subscriptionChangeListeners.add(listener);
+      return function () {
+        _this.subscriptionChangeListeners.delete(listener);
+      };
+    }
+  }, {
+    key: "notifySubscriptionChangeListeners",
+    value: function notifySubscriptionChangeListeners() {
+      var _this2 = this;
+      this.subscriptionChangeListeners.forEach(function (listener) {
+        try {
+          listener();
+        } catch (error) {
+          var _this2$deps$getFireAn;
+          (0, _monitoring.logException)(error, {
+            location: 'editor-synced-block-provider/syncBlockSubscriptionManager/notifySubscriptionChangeListeners'
+          });
+          (_this2$deps$getFireAn = _this2.deps.getFireAnalyticsEvent()) === null || _this2$deps$getFireAn === void 0 || _this2$deps$getFireAn((0, _errorHandling.fetchErrorPayload)(error.message));
+        }
+      });
+    }
+  }, {
+    key: "handleSubscriptionUpdate",
+    value: function handleSubscriptionUpdate(syncBlockInstance) {
+      if (!syncBlockInstance.resourceId) {
+        return;
+      }
+      var existing = this.deps.getFromCache(syncBlockInstance.resourceId);
+      var resolved = existing ? (0, _resolveSyncBlockInstance.resolveSyncBlockInstance)(existing, syncBlockInstance) : syncBlockInstance;
+      this.deps.updateCache(resolved);
+      if (!syncBlockInstance.error) {
+        this.deps.fetchSyncBlockSourceInfo(resolved.resourceId);
+      }
+    }
+  }, {
+    key: "setupSubscription",
+    value: function setupSubscription(resourceId) {
+      var _this3 = this;
+      if (this.graphqlSubscriptions.has(resourceId)) {
+        return;
+      }
+      var dataProvider = this.deps.getDataProvider();
+      if (!(dataProvider !== null && dataProvider !== void 0 && dataProvider.subscribeToBlockUpdates)) {
+        return;
+      }
+      var unsubscribe = dataProvider.subscribeToBlockUpdates(resourceId, function (syncBlockInstance) {
+        _this3.handleGraphQLUpdate(syncBlockInstance);
+      }, function (error) {
+        var _this3$deps$getFireAn;
+        (0, _monitoring.logException)(error, {
+          location: 'editor-synced-block-provider/syncBlockSubscriptionManager/graphql-subscription'
+        });
+        (_this3$deps$getFireAn = _this3.deps.getFireAnalyticsEvent()) === null || _this3$deps$getFireAn === void 0 || _this3$deps$getFireAn((0, _errorHandling.fetchErrorPayload)(error.message));
+      });
+      if (unsubscribe) {
+        this.graphqlSubscriptions.set(resourceId, unsubscribe);
+      }
+    }
+  }, {
+    key: "cleanupSubscription",
+    value: function cleanupSubscription(resourceId) {
+      var unsubscribe = this.graphqlSubscriptions.get(resourceId);
+      if (unsubscribe) {
+        unsubscribe();
+        this.graphqlSubscriptions.delete(resourceId);
+      }
+    }
+  }, {
+    key: "setupSubscriptionsForAllBlocks",
+    value: function setupSubscriptionsForAllBlocks() {
+      var _iterator = _createForOfIteratorHelper(this.deps.getSubscriptions().keys()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var resourceId = _step.value;
+          this.setupSubscription(resourceId);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "cleanupAll",
+    value: function cleanupAll() {
+      var _iterator2 = _createForOfIteratorHelper(this.graphqlSubscriptions.values()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var unsubscribe = _step2.value;
+          unsubscribe();
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      this.graphqlSubscriptions.clear();
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.cleanupAll();
+      this.subscriptionChangeListeners.clear();
+      this.useRealTimeSubscriptions = false;
+    }
+  }, {
+    key: "shouldUseRealTime",
+    value: function shouldUseRealTime() {
+      return this.useRealTimeSubscriptions;
+    }
+  }, {
+    key: "handleGraphQLUpdate",
+    value: function handleGraphQLUpdate(syncBlockInstance) {
+      var _this4 = this;
+      if (!syncBlockInstance.resourceId) {
+        if ((0, _platformFeatureFlags.fg)('platform_synced_block_patch_5')) {
+          return;
+        }
+        throw new Error('Sync block instance provided to graphql subscription update missing resource id');
+      }
+      var existing = this.deps.getFromCache(syncBlockInstance.resourceId);
+      var resolved = existing ? (0, _resolveSyncBlockInstance.resolveSyncBlockInstance)(existing, syncBlockInstance) : syncBlockInstance;
+      this.deps.updateCache(resolved);
+      if (!syncBlockInstance.error) {
+        var callbacks = this.deps.getSubscriptions().get(syncBlockInstance.resourceId);
+        var localIds = callbacks ? Object.keys(callbacks) : [];
+        localIds.forEach(function (localId) {
+          var _this4$deps$getFireAn, _syncBlockInstance$da;
+          (_this4$deps$getFireAn = _this4.deps.getFireAnalyticsEvent()) === null || _this4$deps$getFireAn === void 0 || _this4$deps$getFireAn((0, _errorHandling.fetchSuccessPayload)(syncBlockInstance.resourceId, localId, (_syncBlockInstance$da = syncBlockInstance.data) === null || _syncBlockInstance$da === void 0 ? void 0 : _syncBlockInstance$da.product));
+        });
+        this.deps.fetchSyncBlockSourceInfo(resolved.resourceId);
+      } else {
+        var _syncBlockInstance$er, _syncBlockInstance$er2, _syncBlockInstance$er3, _this$deps$getFireAna;
+        var errorMessage = (0, _platformFeatureFlags.fg)('platform_synced_block_patch_3') ? ((_syncBlockInstance$er = syncBlockInstance.error) === null || _syncBlockInstance$er === void 0 ? void 0 : _syncBlockInstance$er.reason) || ((_syncBlockInstance$er2 = syncBlockInstance.error) === null || _syncBlockInstance$er2 === void 0 ? void 0 : _syncBlockInstance$er2.type) : (_syncBlockInstance$er3 = syncBlockInstance.error) === null || _syncBlockInstance$er3 === void 0 ? void 0 : _syncBlockInstance$er3.type;
+        (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna((0, _errorHandling.fetchErrorPayload)(errorMessage, syncBlockInstance.resourceId));
+      }
+    }
+  }]);
+}();

package/dist/es2019/clients/block-service/blockService.js

@@ -81,6 +81,7 @@ const UPDATE_DOCUMENT_REFERENCES_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_UPDATE_DO
 const BATCH_RETRIEVE_BLOCKS_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_BATCH_RETRIEVE_BLOCKS';
 const GET_BLOCK_REFERENCES_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_GET_REFERENCES';
 const GET_BLOCK_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_GET_BLOCK';
+const BATCH_UPDATE_BLOCKS_OPERATION_NAME = 'EDITOR_SYNCED_BLOCK_BATCH_UPDATE_BLOCKS';
 const buildGetDocumentReferenceBlocksQuery = documentAri => `query ${GET_DOCUMENT_REFERENCE_BLOCKS_OPERATION_NAME} {
 	blockService_getDocumentReferenceBlocks(documentAri: ${fg('platform_synced_block_patch_4') ? JSON.stringify(documentAri) : `"${documentAri}"`}) {
 		blocks {
@@ -257,6 +258,40 @@ const buildGetBlockReferencesQuery = blockAri => {
 	}
 }`;
 };
+const buildBatchUpdateBlocksMutation = blocks => {
+  const blocksArray = blocks.map(block => {
+    const inputParts = [`blockAri: ${JSON.stringify(block.blockAri)}`, `content: ${JSON.stringify(block.content)}`];
+    if (block.stepVersion !== undefined) {
+      inputParts.push(`stepVersion: ${block.stepVersion}`);
+    }
+    if (block.status !== undefined) {
+      inputParts.push(`status: ${JSON.stringify(block.status)}`);
+    }
+    return `{ ${inputParts.join(', ')} }`;
+  }).join(', ');
+  return `mutation ${BATCH_UPDATE_BLOCKS_OPERATION_NAME} {
+	blockService_batchUpdateBlocks(input: { blocks: [${blocksArray}] }) {
+		success {
+			blockAri
+			blockInstanceId
+			content
+			contentUpdatedAt
+			createdAt
+			createdBy
+			deletionReason
+			product
+			sourceAri
+			status
+			version
+		}
+		error {
+			blockAri
+			code
+			reason
+		}
+	}
+}`;
+};
 export class BlockError extends Error {
   constructor(status) {
     super(`Block error`);
@@ -473,4 +508,57 @@ export const getReferenceSyncedBlocksByBlockAri = async ({
     references: graphqlResponse.references || [],
     errors: graphqlResponse.errors || []
   };
+};
+
+/**
+ * Batch updates multiple synced blocks.
+ *
+ * Calls the Block Service GraphQL API: `blockService_batchUpdateBlocks`
+ *
+ * @param blocks - Array of block updates to apply
+ * @returns A promise containing arrays of successfully updated blocks and any errors encountered
+ *
+ * @example
+ * ```typescript
+ * const result = await updateSyncedBlocks({
+ *   blocks: [
+ *     {
+ *       blockAri: 'ari:cloud:blocks:site-123:synced-block/uuid-456',
+ *       content: '{"type":"doc","version":1,"content":[]}',
+ *       status: 'active',
+ *       stepVersion: 42
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+export const updateSyncedBlocks = async ({
+  blocks
+}) => {
+  var _result$data8;
+  const bodyData = {
+    query: buildBatchUpdateBlocksMutation(blocks),
+    operationName: BATCH_UPDATE_BLOCKS_OPERATION_NAME
+  };
+  const url = fg('platform_synced_block_patch_3') ? `${GRAPHQL_ENDPOINT}?operation=editorSyncedBlockBatchUpdateBlocks` : GRAPHQL_ENDPOINT;
+  const response = await fetchWithRetry(url, {
+    method: 'POST',
+    headers: COMMON_HEADERS,
+    body: JSON.stringify(bodyData)
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+  const result = await response.json();
+  if (result.errors && result.errors.length > 0) {
+    throw new Error(result.errors.map(e => e.message).join(', '));
+  }
+  if (!((_result$data8 = result.data) !== null && _result$data8 !== void 0 && _result$data8.blockService_batchUpdateBlocks)) {
+    throw new Error('No data returned from GraphQL mutation');
+  }
+  const graphqlResponse = result.data.blockService_batchUpdateBlocks;
+  return {
+    success: graphqlResponse.success,
+    error: graphqlResponse.error
+  };
 };

package/dist/es2019/clients/block-service/blockSubscription.js

@@ -1,6 +1,6 @@
 import { createClient } from 'graphql-ws';
 import { isSSR } from '@atlaskit/editor-common/core-utils';
-import { BLOCK_SERVICE_SUBSCRIPTION_QUERY, parseSubscriptionPayload } from './sharedSubscriptionUtils';
+import { convertContentUpdatedAt } from '../../utils/utils';
 const GRAPHQL_WS_ENDPOINT = '/gateway/api/graphql/subscriptions';
 let blockServiceClient = null;
 const getBlockServiceClient = () => {
@@ -19,6 +19,66 @@ const getBlockServiceClient = () => {
   }
   return blockServiceClient;
 };
+const SUBSCRIPTION_QUERY = `
+subscription EDITOR_SYNCED_BLOCK_ON_BLOCK_UPDATED($resourceId: ID!) {
+	blockService_onBlockUpdated(resourceId: $resourceId) {
+		blockAri
+		blockInstanceId
+		content
+		contentUpdatedAt
+		createdAt
+		createdBy
+		deletionReason
+		product
+		sourceAri
+		status
+	}
+}
+`;
+/**
+ * Extracts the resourceId from a block ARI.
+ * Block ARI format: ari:cloud:blocks:<cloudId>:synced-block/<resourceId>
+ * @param blockAri - The block ARI string
+ * @returns The resourceId portion of the ARI
+ */
+const extractResourceIdFromBlockAri = blockAri => {
+  // eslint-disable-next-line require-unicode-regexp
+  const match = blockAri.match(/ari:cloud:blocks:[^:]+:synced-block\/(.+)$/);
+  return (match === null || match === void 0 ? void 0 : match[1]) || null;
+};
+
+/**
+ * Parses the subscription payload into a standardized format.
+ * @param payload - The raw subscription payload
+ * @returns Parsed block data or null if parsing fails
+ */
+const parseSubscriptionPayload = payload => {
+  try {
+    const resourceId = extractResourceIdFromBlockAri(payload.blockAri);
+    if (!resourceId) {
+      return null;
+    }
+    let createdAt;
+    if (payload.createdAt !== undefined && payload.createdAt !== null) {
+      createdAt = new Date(payload.createdAt).toISOString();
+    }
+    return {
+      blockAri: payload.blockAri,
+      blockInstanceId: payload.blockInstanceId,
+      content: JSON.parse(payload.content),
+      contentUpdatedAt: convertContentUpdatedAt(payload.contentUpdatedAt),
+      createdAt,
+      createdBy: payload.createdBy,
+      product: payload.product,
+      resourceId,
+      sourceAri: payload.sourceAri,
+      status: payload.status
+    };
+  } catch {
+    return null;
+  }
+};
+
 /**
  * Creates a GraphQL subscription to block updates using the shared graphql-ws client.
  *
@@ -34,7 +94,7 @@ export const subscribeToBlockUpdates = (blockAri, onData, onError) => {
     return () => {};
   }
   const unsubscribe = client.subscribe({
-    query: BLOCK_SERVICE_SUBSCRIPTION_QUERY,
+    query: SUBSCRIPTION_QUERY,
     variables: {
       resourceId: blockAri
     },

package/dist/es2019/index.js

@@ -10,13 +10,13 @@ export { useHandleContentChanges } from './hooks/useHandleContentChanges';
 
 // clients
 export { generateBlockAri, generateBlockAriFromReference, getLocalIdFromBlockResourceId } from './clients/block-service/ari';
-export { BlockError } from './clients/block-service/blockService';
+export { BlockError, updateSyncedBlocks } from './clients/block-service/blockService';
 export { getConfluencePageAri, getPageIdAndTypeFromConfluencePageAri } from './clients/confluence/ari';
 export { fetchMediaToken } from './clients/confluence/fetchMediaToken';
 export { getJiraWorkItemAri, getJiraWorkItemIdFromAri } from './clients/jira/ari';
 
 // providers
-export { useMemoizedBlockServiceAPIProviders, useMemoizedBlockServiceFetchOnlyAPIProvider, fetchReferences, batchFetchData, blockAriToResourceId, convertToSyncBlockData, extractResourceIdFromBlockAri } from './providers/block-service/blockServiceAPI';
+export { useMemoizedBlockServiceAPIProviders, useMemoizedBlockServiceFetchOnlyAPIProvider, fetchReferences, batchFetchData, writeDataBatch, blockAriToResourceId, convertToSyncBlockData, extractResourceIdFromBlockAri } from './providers/block-service/blockServiceAPI';
 export { fetchConfluencePageInfo } from './clients/confluence/sourceInfo';
 export { SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './providers/syncBlockProvider';
 // store managers
@@ -25,10 +25,6 @@ export { SyncBlockInMemorySessionCache, syncBlockInMemorySessionCache } from './
 export { SyncBlockStoreManager, useMemoizedSyncBlockStoreManager } from './store-manager/syncBlockStoreManager';
 
 // utils
-export { BLOCK_SERVICE_SUBSCRIPTION_QUERY } from './clients/block-service/sharedSubscriptionUtils';
-export { parseSubscriptionPayload } from './clients/block-service/sharedSubscriptionUtils';
-export { convertRelayResponseToSyncBlockInstance } from './utils/relayResponseConverter';
-export { createRelayBlockSubscription, createRelaySubscriptionFunction } from './utils/relaySubscriptionUtils';
 export { resolveSyncBlockInstance } from './utils/resolveSyncBlockInstance';
 export { parseResourceId, createResourceIdForReference } from './utils/resourceId';
 export { createSyncBlockNode, convertSyncBlockPMNodeToSyncBlockData, convertSyncBlockJSONNodeToSyncBlockNode, convertPMNodesToSyncBlockNodes, getContentIdAndProductFromResourceId } from './utils/utils';

package/dist/es2019/providers/block-service/blockServiceAPI.js

@@ -2,11 +2,10 @@
 import { useMemo } from 'react';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { generateBlockAri, generateBlockAriFromReference } from '../../clients/block-service/ari';
-import { batchRetrieveSyncedBlocks, BlockError, createSyncedBlock, deleteSyncedBlock, getReferenceSyncedBlocks, getReferenceSyncedBlocksByBlockAri, getSyncedBlockContent, updateReferenceSyncedBlockOnDocument, updateSyncedBlock } from '../../clients/block-service/blockService';
+import { batchRetrieveSyncedBlocks, BlockError, createSyncedBlock, deleteSyncedBlock, getReferenceSyncedBlocks, getReferenceSyncedBlocksByBlockAri, getSyncedBlockContent, updateReferenceSyncedBlockOnDocument, updateSyncedBlock, updateSyncedBlocks } from '../../clients/block-service/blockService';
 import { subscribeToBlockUpdates as subscribeToBlockUpdatesWS } from '../../clients/block-service/blockSubscription';
 import { SyncBlockError } from '../../common/types';
 import { stringifyError } from '../../utils/errorHandling';
-import { createRelaySubscriptionFunction } from '../../utils/relaySubscriptionUtils';
 import { createResourceIdForReference } from '../../utils/resourceId';
 import { convertContentUpdatedAt } from '../../utils/utils';
 const mapBlockError = error => {
@@ -308,18 +307,102 @@ export const batchFetchData = async (cloudId, parentAri, blockNodeIdentifiers) =
     }));
   }
 };
+
+/**
+ * Batch writes multiple synced blocks.
+ * @param cloudId - The cloudId of the block. E.G the cloudId of the confluence page, or the cloudId of the Jira instance
+ * @param parentAri - The ARI of the parent of the block. E.G the ARI of the confluence page, or the ARI of the Jira work item
+ * @param parentId - The parentId of the block. E.G the pageId for a confluence page, or the issueId for a Jira work item
+ * @param product - The product of the block. E.G 'confluence-page', 'jira-work-item'
+ * @param data - Array of SyncBlockData to write
+ * @param stepVersion - Optional version number
+ * @returns Array of WriteSyncBlockResult results
+ */
+export const writeDataBatch = async (cloudId, parentAri, parentId, product, data, stepVersion) => {
+  if (!parentAri || !parentId) {
+    return data.map(block => ({
+      error: SyncBlockError.Errored,
+      resourceId: block.resourceId
+    }));
+  }
+  try {
+    // Create a map from blockAri to original resourceId for matching responses
+    const blockAriToResourceIdMap = new Map();
+    const blocks = data.map(block => {
+      const blockAri = generateBlockAri({
+        cloudId,
+        parentId,
+        product,
+        resourceId: block.resourceId
+      });
+      blockAriToResourceIdMap.set(blockAri, block.resourceId);
+      return {
+        blockAri,
+        content: JSON.stringify(block.content),
+        status: block.status,
+        stepVersion
+      };
+    });
+    const response = await updateSyncedBlocks({
+      blocks
+    });
+    const results = [];
+
+    // Process successful updates
+    if (response.success) {
+      const successResourceIds = new Set(response.success.map(block => blockAriToResourceIdMap.get(block.blockAri)));
+      for (const block of data) {
+        if (successResourceIds.has(block.resourceId)) {
+          results.push({
+            resourceId: block.resourceId
+          });
+        }
+      }
+    }
+    if (response.error) {
+      const errorResourceIds = new Map(response.error.map(err => [
+      // Use the map to get the original resourceId
+      blockAriToResourceIdMap.get(err.blockAri) || '', mapErrorResponseCode(err.code)]));
+      for (const block of data) {
+        const error = errorResourceIds.get(block.resourceId);
+        if (error) {
+          results.push({
+            error,
+            resourceId: block.resourceId
+          });
+        } else if (!results.some(r => r.resourceId === block.resourceId)) {
+          // If not in success or error lists, mark as errored
+          results.push({
+            error: SyncBlockError.Errored,
+            resourceId: block.resourceId
+          });
+        }
+      }
+    }
+    return results;
+  } catch (error) {
+    if (error instanceof BlockError) {
+      return data.map(block => ({
+        error: mapBlockError(error),
+        resourceId: block.resourceId
+      }));
+    }
+    return data.map(block => ({
+      error: stringifyError(error),
+      resourceId: block.resourceId
+    }));
+  }
+};
 /**
  * ADFFetchProvider implementation that fetches synced block data from Block Service API
  */
 class BlockServiceADFFetchProvider {
   constructor({
     cloudId,
-    parentAri,
-    relayEnvironment
+    parentAri
   }) {
     this.cloudId = cloudId;
     this.parentAri = parentAri;
-    this.relayEnvironment = relayEnvironment;
   }
 
   // resourceId of the reference synced block.
@@ -445,7 +528,6 @@ class BlockServiceADFFetchProvider {
 
   /**
    * Subscribes to real-time updates for a specific block using GraphQL WebSocket subscriptions.
-   * If a Relay environment is provided, uses Relay subscriptions; otherwise falls back to WebSocket.
    * @param resourceId - The resource ID of the block to subscribe to
    * @param onUpdate - Callback function invoked when the block is updated
    * @param onError - Optional callback function invoked on subscription errors
@@ -456,14 +538,6 @@ class BlockServiceADFFetchProvider {
       cloudId: this.cloudId,
       resourceId
     });
-
-    // If Relay environment is available, use Relay subscriptions
-    if (this.relayEnvironment && fg('platform_synced_block_patch_3')) {
-      const relaySubscribeToBlockUpdates = createRelaySubscriptionFunction(this.cloudId, this.relayEnvironment);
-      return relaySubscribeToBlockUpdates(resourceId, onUpdate, onError);
-    }
-
-    // Fall back to WebSocket subscriptions
     return subscribeToBlockUpdatesWS(blockAri, parsedData => {
       // Convert ParsedBlockSubscriptionData to SyncBlockInstance
       const syncBlockInstance = {
@@ -643,6 +717,14 @@ class BlockServiceADFWriteProvider {
   generateResourceId() {
     return crypto.randomUUID();
   }
+  generateBlockAri(resourceId) {
+    return generateBlockAri({
+      cloudId: this.cloudId,
+      parentId: this.parentId || '',
+      product: this.product,
+      resourceId
+    });
+  }
   async updateReferenceData(blocks, noContent) {
     if (!this.parentAri) {
       return {
@@ -678,20 +760,89 @@ class BlockServiceADFWriteProvider {
       };
     }
   }
+  async writeDataBatch(data) {
+    if (!this.parentAri || !this.parentId) {
+      return data.map(block => ({
+        error: SyncBlockError.Errored,
+        resourceId: block.resourceId
+      }));
+    }
+    const stepVersion = this.getVersion ? await this.getVersion() : undefined;
+    try {
+      // Create a map from blockAri to original resourceId for matching responses
+      const blockAriToResourceIdMap = new Map();
+      const blocks = data.map(block => {
+        const blockAri = this.generateBlockAri(block.resourceId);
+        blockAriToResourceIdMap.set(blockAri, block.resourceId);
+        return {
+          blockAri,
+          content: JSON.stringify(block.content),
+          status: block.status,
+          stepVersion
+        };
+      });
+      const response = await updateSyncedBlocks({
+        blocks
+      });
+      const results = [];
+
+      // Process successful updates
+      if (response.success) {
+        const successResourceIds = new Set(response.success.map(block => blockAriToResourceIdMap.get(block.blockAri)));
+        for (const block of data) {
+          if (successResourceIds.has(block.resourceId)) {
+            results.push({
+              resourceId: block.resourceId
+            });
+          }
+        }
+      }
+      if (response.error) {
+        const errorResourceIds = new Map(response.error.map(err => [
+        // Use the map to get the original resourceId
+        blockAriToResourceIdMap.get(err.blockAri) || '', mapErrorResponseCode(err.code)]));
+        for (const block of data) {
+          const error = errorResourceIds.get(block.resourceId);
+          if (error) {
+            results.push({
+              error,
+              resourceId: block.resourceId
+            });
+          } else if (!results.some(r => r.resourceId === block.resourceId)) {
+            // If not in success or error lists, mark as errored
+            results.push({
+              error: SyncBlockError.Errored,
+              resourceId: block.resourceId
+            });
+          }
+        }
+      }
+      return results;
+    } catch (error) {
+      if (error instanceof BlockError) {
+        return data.map(block => ({
+          error: mapBlockError(error),
+          resourceId: block.resourceId
+        }));
+      }
+      return data.map(block => ({
+        error: stringifyError(error),
+        resourceId: block.resourceId
+      }));
+    }
+  }
 }
 const createBlockServiceAPIProviders = ({
   cloudId,
   parentAri,
   parentId,
   product,
-  getVersion,
-  relayEnvironment
+  getVersion
 }) => {
   return {
     fetchProvider: new BlockServiceADFFetchProvider({
       cloudId,
-      parentAri,
-      relayEnvironment
+      parentAri
     }),
     writeProvider: new BlockServiceADFWriteProvider({
       cloudId,
@@ -707,8 +858,7 @@ export const useMemoizedBlockServiceAPIProviders = ({
   parentAri,
   parentId,
   product,
-  getVersion,
-  relayEnvironment
+  getVersion
 }) => {
   return useMemo(() => {
     return createBlockServiceAPIProviders({
@@ -716,10 +866,9 @@ export const useMemoizedBlockServiceAPIProviders = ({
       parentAri,
       parentId,
       product,
-      getVersion,
-      relayEnvironment
+      getVersion
     });
-  }, [cloudId, parentAri, parentId, product, getVersion, relayEnvironment]);
+  }, [cloudId, parentAri, parentId, product, getVersion]);
 };
 const createBlockServiceFetchOnlyAPIProvider = ({
   cloudId,