@atlaskit/editor-synced-block-provider 3.8.1 → 3.10.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atlaskit/editor-synced-block-provider
 
+## 3.10.0
+
+### Minor Changes
+
+- [`7638bd91b6c72`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/7638bd91b6c72) -
+  The errors should render correctly when using batch-retrieve to fetch synced blocks
+
+## 3.9.0
+
+### Minor Changes
+
+- [`fe0f9c8de91c3`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/fe0f9c8de91c3) -
+  The batch retrieve of the blocks must also send document ARI and also the local instance ID of the
+  reference blocks
+
 ## 3.8.1
 
 ### Patch Changes

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

@@ -137,11 +137,11 @@ var BlockError = exports.BlockError = /*#__PURE__*/function (_Error) {
 }( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
 var getSyncedBlockContent = exports.getSyncedBlockContent = /*#__PURE__*/function () {
   var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(_ref2) {
-    var blockAri, documentAri, queryParams, response;
+    var blockAri, queryParams, response;
     return _regenerator.default.wrap(function _callee2$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
         case 0:
-          blockAri = _ref2.blockAri, documentAri = _ref2.documentAri;
+          blockAri = _ref2.blockAri;
           // Disable sending documentAri for now. We'll add it back if we find a way to update references that follows the save & refresh principle.
           // Slack discussion here: https://atlassian.slack.com/archives/C09DZT1TBNW/p1767836775552099?thread_ts=1767836754.024889&cid=C09DZT1TBNW
           // const queryParams = documentAri ? `?documentAri=${encodeURIComponent(documentAri)}` : '';
@@ -184,17 +184,21 @@ var getSyncedBlockContent = exports.getSyncedBlockContent = /*#__PURE__*/functio
  */
 var batchRetrieveSyncedBlocks = exports.batchRetrieveSyncedBlocks = /*#__PURE__*/function () {
   var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(_ref4) {
-    var blockAris, response;
+    var blockIdentifiers, documentAri, response;
     return _regenerator.default.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
-          blockAris = _ref4.blockAris;
+          blockIdentifiers = _ref4.blockIdentifiers, documentAri = _ref4.documentAri;
           _context3.next = 3;
           return (0, _retry.fetchWithRetry)("".concat(BLOCK_SERVICE_API_URL, "/block/batch-retrieve"), {
             method: 'POST',
             headers: COMMON_HEADERS,
             body: JSON.stringify({
-              blockAris: blockAris
+              documentAri: documentAri,
+              blockIdentifiers: blockIdentifiers,
+              blockAris: blockIdentifiers.map(function (blockIdentifier) {
+                return blockIdentifier.blockAri;
+              })
             })
           });
         case 3:

package/dist/cjs/hooks/useFetchSyncBlockTitle.js

@@ -8,7 +8,19 @@ exports.useFetchSyncBlockTitle = void 0;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _react = require("react");
 var useFetchSyncBlockTitle = exports.useFetchSyncBlockTitle = function useFetchSyncBlockTitle(manager, syncBlockNode) {
-  var _useState = (0, _react.useState)(undefined),
+  // Initialize state from cache to prevent flickering during re-renders
+  var _useState = (0, _react.useState)(function () {
+      var _cachedData$data;
+      if (syncBlockNode.type.name !== 'syncBlock') {
+        return undefined;
+      }
+      var resourceId = syncBlockNode.attrs.resourceId;
+      if (!resourceId) {
+        return undefined;
+      }
+      var cachedData = manager.referenceManager.getFromCache(resourceId);
+      return cachedData === null || cachedData === void 0 || (_cachedData$data = cachedData.data) === null || _cachedData$data === void 0 ? void 0 : _cachedData$data.sourceTitle;
+    }),
     _useState2 = (0, _slicedToArray2.default)(_useState, 2),
     sourceTitle = _useState2[0],
     setSourceTitle = _useState2[1];

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

@@ -17,7 +17,7 @@ var _ari = require("../../clients/block-service/ari");
 var _blockService = require("../../clients/block-service/blockService");
 var _types = require("../../common/types");
 var _errorHandling = require("../../utils/errorHandling");
-var _resourceId3 = require("../../utils/resourceId");
+var _resourceId2 = require("../../utils/resourceId");
 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; }
@@ -43,6 +43,26 @@ var mapBlockError = function mapBlockError(error) {
   }
   return _types.SyncBlockError.Errored;
 };
+var mapErrorResponseCode = function mapErrorResponseCode(errorCode) {
+  switch (errorCode) {
+    case 'FORBIDDEN':
+      return _types.SyncBlockError.Forbidden;
+    case 'NOT_FOUND':
+      return _types.SyncBlockError.NotFound;
+    case 'INVALID_REQUEST':
+      return _types.SyncBlockError.InvalidRequest;
+    case 'CONFLICT':
+      return _types.SyncBlockError.Conflict;
+    case 'RATE_LIMITED':
+      return _types.SyncBlockError.RateLimited;
+    case 'SERVER_ERROR':
+      return _types.SyncBlockError.ServerError;
+    case 'INVALID_CONTENT':
+      return _types.SyncBlockError.InvalidContent;
+    default:
+      return _types.SyncBlockError.Errored;
+  }
+};
 
 /**
  * Extracts the ResourceId from a block ARI by returning the full path after synced-block/.
@@ -326,67 +346,84 @@ var BlockServiceADFFetchProvider = /*#__PURE__*/function () {
 
     /**
      * Batch fetches multiple synced blocks by their resource IDs.
-     * @param resourceIds - Array of resource IDs to fetch
+     * @param blockNodeIdentifiers - Array of block node identifiers, containing block instance (local) ID + resource IDs to fetch
      * @returns Array of SyncBlockInstance results
      */
   }, {
     key: "batchFetchData",
     value: (function () {
-      var _batchFetchData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(resourceIds) {
+      var _batchFetchData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(blockNodeIdentifiers) {
         var _this2 = this;
-        var blockAris, validResourceIds, processedResourceIds, response, results, _iterator, _step, blockContentResponse, resourceId, value, syncedBlockData, _iterator2, _step2, errorResponse, _resourceId, _iterator3, _step3, _resourceId2;
+        var blockIdentifiers, validResourceIds, processedResourceIds, response, results, _iterator, _step, blockContentResponse, resourceId, value, syncedBlockData, _iterator2, _step2, errorResponse, _resourceId, _iterator3, _step3, blockNodeIdentifier;
         return _regenerator.default.wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
-              blockAris = resourceIds.map(function (resourceId) {
-                return (0, _ari.generateBlockAriFromReference)({
-                  cloudId: _this2.cloudId,
-                  resourceId: resourceId
-                });
+              blockIdentifiers = blockNodeIdentifiers.map(function (blockIdentifier) {
+                return {
+                  blockAri: (0, _ari.generateBlockAriFromReference)({
+                    cloudId: _this2.cloudId,
+                    resourceId: blockIdentifier.resourceId
+                  }),
+                  blockInstanceId: blockIdentifier.blockInstanceId
+                };
               }); // Create a set of valid resourceIds for validation
-              validResourceIds = new Set(resourceIds); // Track which resourceIds have been processed
+              validResourceIds = new Set(blockNodeIdentifiers.map(function (blockNodeIdentifier) {
+                return blockNodeIdentifier.resourceId;
+              })); // Track which resourceIds have been processed
               processedResourceIds = new Set();
-              _context4.prev = 3;
-              _context4.next = 6;
+              if (this.parentAri) {
+                _context4.next = 5;
+                break;
+              }
+              return _context4.abrupt("return", blockNodeIdentifiers.map(function (blockNodeIdentifier) {
+                return {
+                  error: _types.SyncBlockError.Errored,
+                  resourceId: blockNodeIdentifier.resourceId
+                };
+              }));
+            case 5:
+              _context4.prev = 5;
+              _context4.next = 8;
               return (0, _blockService.batchRetrieveSyncedBlocks)({
-                blockAris: blockAris
+                documentAri: this.parentAri,
+                blockIdentifiers: blockIdentifiers
               });
-            case 6:
+            case 8:
               response = _context4.sent;
               results = []; // Process successful blocks
               if (!response.success) {
-                _context4.next = 33;
+                _context4.next = 35;
                 break;
               }
               _iterator = _createForOfIteratorHelper(response.success);
-              _context4.prev = 10;
+              _context4.prev = 12;
               _iterator.s();
-            case 12:
+            case 14:
               if ((_step = _iterator.n()).done) {
-                _context4.next = 25;
+                _context4.next = 27;
                 break;
               }
               blockContentResponse = _step.value;
               // Extract resourceId from the returned blockAri
               resourceId = this.extractResourceIdFromBlockAri(blockContentResponse.blockAri);
               if (!(!resourceId || !validResourceIds.has(resourceId))) {
-                _context4.next = 17;
+                _context4.next = 19;
                 break;
               }
-              return _context4.abrupt("continue", 23);
-            case 17:
+              return _context4.abrupt("continue", 25);
+            case 19:
               processedResourceIds.add(resourceId);
               value = blockContentResponse.content;
               if (value) {
-                _context4.next = 22;
+                _context4.next = 24;
                 break;
               }
               results.push({
                 error: _types.SyncBlockError.NotFound,
                 resourceId: resourceId
               });
-              return _context4.abrupt("continue", 23);
-            case 22:
+              return _context4.abrupt("continue", 25);
+            case 24:
               try {
                 syncedBlockData = JSON.parse(value);
                 results.push({
@@ -405,71 +442,71 @@ var BlockServiceADFFetchProvider = /*#__PURE__*/function () {
                   resourceId: resourceId
                 });
               }
-            case 23:
-              _context4.next = 12;
-              break;
             case 25:
-              _context4.next = 30;
+              _context4.next = 14;
               break;
             case 27:
-              _context4.prev = 27;
-              _context4.t0 = _context4["catch"](10);
+              _context4.next = 32;
+              break;
+            case 29:
+              _context4.prev = 29;
+              _context4.t0 = _context4["catch"](12);
               _iterator.e(_context4.t0);
-            case 30:
-              _context4.prev = 30;
+            case 32:
+              _context4.prev = 32;
               _iterator.f();
-              return _context4.finish(30);
-            case 33:
+              return _context4.finish(32);
+            case 35:
               if (!response.error) {
-                _context4.next = 54;
+                _context4.next = 56;
                 break;
               }
               _iterator2 = _createForOfIteratorHelper(response.error);
-              _context4.prev = 35;
+              _context4.prev = 37;
               _iterator2.s();
-            case 37:
+            case 39:
               if ((_step2 = _iterator2.n()).done) {
-                _context4.next = 46;
+                _context4.next = 48;
                 break;
               }
               errorResponse = _step2.value;
               // Extract resourceId from the returned blockAri
               _resourceId = this.extractResourceIdFromBlockAri(errorResponse.blockAri);
               if (!(!_resourceId || !validResourceIds.has(_resourceId))) {
-                _context4.next = 42;
+                _context4.next = 44;
                 break;
               }
-              return _context4.abrupt("continue", 44);
-            case 42:
+              return _context4.abrupt("continue", 46);
+            case 44:
               processedResourceIds.add(_resourceId);
               results.push({
-                error: _types.SyncBlockError.Errored,
+                error: mapErrorResponseCode(errorResponse.code),
                 resourceId: _resourceId
               });
-            case 44:
-              _context4.next = 37;
-              break;
             case 46:
-              _context4.next = 51;
+              _context4.next = 39;
               break;
             case 48:
-              _context4.prev = 48;
-              _context4.t1 = _context4["catch"](35);
+              _context4.next = 53;
+              break;
+            case 50:
+              _context4.prev = 50;
+              _context4.t1 = _context4["catch"](37);
               _iterator2.e(_context4.t1);
-            case 51:
-              _context4.prev = 51;
+            case 53:
+              _context4.prev = 53;
               _iterator2.f();
-              return _context4.finish(51);
-            case 54:
+              return _context4.finish(53);
+            case 56:
               // Ensure all resourceIds have a result - return NotFound for any missing ones
-              _iterator3 = _createForOfIteratorHelper(resourceIds);
+              _iterator3 = _createForOfIteratorHelper(blockNodeIdentifiers);
               try {
                 for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                  _resourceId2 = _step3.value;
-                  if (!processedResourceIds.has(_resourceId2)) {
+                  blockNodeIdentifier = _step3.value;
+                  if (!processedResourceIds.has(blockNodeIdentifier.resourceId)) {
                     results.push({
                       error: _types.SyncBlockError.NotFound,
-                      resourceId: _resourceId2
+                      resourceId: blockNodeIdentifier.resourceId
                     });
                   }
                 }
@@ -479,20 +516,20 @@ var BlockServiceADFFetchProvider = /*#__PURE__*/function () {
                 _iterator3.f();
               }
               return _context4.abrupt("return", results);
-            case 59:
-              _context4.prev = 59;
-              _context4.t2 = _context4["catch"](3);
-              return _context4.abrupt("return", resourceIds.map(function (resourceId) {
+            case 61:
+              _context4.prev = 61;
+              _context4.t2 = _context4["catch"](5);
+              return _context4.abrupt("return", blockNodeIdentifiers.map(function (blockNodeIdentifier) {
                 return {
                   error: _context4.t2 instanceof _blockService.BlockError ? mapBlockError(_context4.t2) : _types.SyncBlockError.Errored,
-                  resourceId: resourceId
+                  resourceId: blockNodeIdentifier.resourceId
                 };
               }));
-            case 62:
+            case 64:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[3, 59], [10, 27, 30, 33], [35, 48, 51, 54]]);
+        }, _callee4, this, [[5, 61], [12, 29, 32, 35], [37, 50, 53, 56]]);
       }));
       function batchFetchData(_x4) {
         return _batchFetchData.apply(this, arguments);
@@ -723,7 +760,7 @@ var BlockServiceADFWriteProvider = /*#__PURE__*/function () {
   }, {
     key: "generateResourceIdForReference",
     value: function generateResourceIdForReference(sourceId) {
-      return (0, _resourceId3.createResourceIdForReference)(this.product, this.parentId || '', sourceId);
+      return (0, _resourceId2.createResourceIdForReference)(this.product, this.parentId || '', sourceId);
     }
   }, {
     key: "generateResourceId",

package/dist/cjs/providers/syncBlockProvider.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useMemoizedSyncedBlockProvider = exports.SyncBlockProvider = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -88,49 +87,51 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
     value: (function () {
       var _fetchNodesData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(nodes) {
         var _this2 = this;
-        var resourceIdSet, resourceIds;
+        var blockIdentifiers;
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              resourceIdSet = new Set(nodes.map(function (node) {
-                return node.attrs.resourceId;
-              }));
-              resourceIds = (0, _toConsumableArray2.default)(resourceIdSet);
-              if (!(resourceIds.length === 0)) {
-                _context.next = 4;
+              blockIdentifiers = nodes.map(function (node) {
+                return {
+                  resourceId: node.attrs.resourceId,
+                  blockInstanceId: node.attrs.localId
+                };
+              });
+              if (!(blockIdentifiers.length === 0)) {
+                _context.next = 3;
                 break;
               }
               return _context.abrupt("return", []);
-            case 4:
+            case 3:
               if (!(0, _platformFeatureFlags.fg)('platform_synced_block_dogfooding')) {
-                _context.next = 16;
+                _context.next = 15;
                 break;
               }
-              _context.prev = 5;
-              _context.next = 8;
-              return this.fetchProvider.batchFetchData(resourceIds);
-            case 8:
+              _context.prev = 4;
+              _context.next = 7;
+              return this.fetchProvider.batchFetchData(blockIdentifiers);
+            case 7:
               return _context.abrupt("return", _context.sent);
-            case 11:
-              _context.prev = 11;
-              _context.t0 = _context["catch"](5);
-              return _context.abrupt("return", resourceIds.map(function (resourceId) {
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](4);
+              return _context.abrupt("return", blockIdentifiers.map(function (blockIdentifier) {
                 return {
                   error: _types.SyncBlockError.Errored,
-                  resourceId: resourceId
+                  resourceId: blockIdentifier.resourceId
                 };
               }));
-            case 14:
-              _context.next = 17;
+            case 13:
+              _context.next = 16;
               break;
-            case 16:
-              return _context.abrupt("return", Promise.allSettled(resourceIds.map(function (resourceId) {
-                return _this2.fetchProvider.fetchData(resourceId).then(function (data) {
+            case 15:
+              return _context.abrupt("return", Promise.allSettled(blockIdentifiers.map(function (blockIdentifier) {
+                return _this2.fetchProvider.fetchData(blockIdentifier.resourceId).then(function (data) {
                   return data;
                 }, function () {
                   return {
                     error: _types.SyncBlockError.Errored,
-                    resourceId: resourceId
+                    resourceId: blockIdentifier.resourceId
                   };
                 });
               })).then(function (results) {
@@ -140,11 +141,11 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
                   return result.value;
                 });
               }));
-            case 17:
+            case 16:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[5, 11]]);
+        }, _callee, this, [[4, 10]]);
       }));
       function fetchNodesData(_x) {
         return _fetchNodesData.apply(this, arguments);

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

@@ -100,8 +100,8 @@ export class BlockError extends Error {
   }
 }
 export const getSyncedBlockContent = async ({
-  blockAri,
-  documentAri
+  blockAri
+  // documentAri,
 }) => {
   // Disable sending documentAri for now. We'll add it back if we find a way to update references that follows the save & refresh principle.
   // Slack discussion here: https://atlassian.slack.com/archives/C09DZT1TBNW/p1767836775552099?thread_ts=1767836754.024889&cid=C09DZT1TBNW
@@ -126,13 +126,16 @@ export const getSyncedBlockContent = async ({
  * @returns A promise containing arrays of successfully fetched blocks and any errors encountered
  */
 export const batchRetrieveSyncedBlocks = async ({
-  blockAris
+  blockIdentifiers,
+  documentAri
 }) => {
   const response = await fetchWithRetry(`${BLOCK_SERVICE_API_URL}/block/batch-retrieve`, {
     method: 'POST',
     headers: COMMON_HEADERS,
     body: JSON.stringify({
-      blockAris
+      documentAri,
+      blockIdentifiers,
+      blockAris: blockIdentifiers.map(blockIdentifier => blockIdentifier.blockAri)
     })
   });
   if (!response.ok) {

package/dist/es2019/hooks/useFetchSyncBlockTitle.js

@@ -1,6 +1,20 @@
 import { useEffect, useState } from 'react';
 export const useFetchSyncBlockTitle = (manager, syncBlockNode) => {
-  const [sourceTitle, setSourceTitle] = useState(undefined);
+  // Initialize state from cache to prevent flickering during re-renders
+  const [sourceTitle, setSourceTitle] = useState(() => {
+    var _cachedData$data;
+    if (syncBlockNode.type.name !== 'syncBlock') {
+      return undefined;
+    }
+    const {
+      resourceId
+    } = syncBlockNode.attrs;
+    if (!resourceId) {
+      return undefined;
+    }
+    const cachedData = manager.referenceManager.getFromCache(resourceId);
+    return cachedData === null || cachedData === void 0 ? void 0 : (_cachedData$data = cachedData.data) === null || _cachedData$data === void 0 ? void 0 : _cachedData$data.sourceTitle;
+  });
   useEffect(() => {
     const unsubscribe = manager.referenceManager.subscribeToSourceTitle(syncBlockNode, title => {
       setSourceTitle(title);

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

@@ -26,6 +26,26 @@ const mapBlockError = error => {
   }
   return SyncBlockError.Errored;
 };
+const mapErrorResponseCode = errorCode => {
+  switch (errorCode) {
+    case 'FORBIDDEN':
+      return SyncBlockError.Forbidden;
+    case 'NOT_FOUND':
+      return SyncBlockError.NotFound;
+    case 'INVALID_REQUEST':
+      return SyncBlockError.InvalidRequest;
+    case 'CONFLICT':
+      return SyncBlockError.Conflict;
+    case 'RATE_LIMITED':
+      return SyncBlockError.RateLimited;
+    case 'SERVER_ERROR':
+      return SyncBlockError.ServerError;
+    case 'INVALID_CONTENT':
+      return SyncBlockError.InvalidContent;
+    default:
+      return SyncBlockError.Errored;
+  }
+};
 
 /**
  * Extracts the ResourceId from a block ARI by returning the full path after synced-block/.
@@ -236,23 +256,33 @@ class BlockServiceADFFetchProvider {
 
   /**
    * Batch fetches multiple synced blocks by their resource IDs.
-   * @param resourceIds - Array of resource IDs to fetch
+   * @param blockNodeIdentifiers - Array of block node identifiers, containing block instance (local) ID + resource IDs to fetch
    * @returns Array of SyncBlockInstance results
    */
-  async batchFetchData(resourceIds) {
-    const blockAris = resourceIds.map(resourceId => generateBlockAriFromReference({
-      cloudId: this.cloudId,
-      resourceId
+  async batchFetchData(blockNodeIdentifiers) {
+    const blockIdentifiers = blockNodeIdentifiers.map(blockIdentifier => ({
+      blockAri: generateBlockAriFromReference({
+        cloudId: this.cloudId,
+        resourceId: blockIdentifier.resourceId
+      }),
+      blockInstanceId: blockIdentifier.blockInstanceId
     }));
 
     // Create a set of valid resourceIds for validation
-    const validResourceIds = new Set(resourceIds);
+    const validResourceIds = new Set(blockNodeIdentifiers.map(blockNodeIdentifier => blockNodeIdentifier.resourceId));
 
     // Track which resourceIds have been processed
     const processedResourceIds = new Set();
+    if (!this.parentAri) {
+      return blockNodeIdentifiers.map(blockNodeIdentifier => ({
+        error: SyncBlockError.Errored,
+        resourceId: blockNodeIdentifier.resourceId
+      }));
+    }
     try {
       const response = await batchRetrieveSyncedBlocks({
-        blockAris
+        documentAri: this.parentAri,
+        blockIdentifiers
       });
       const results = [];
 
@@ -304,27 +334,27 @@ class BlockServiceADFFetchProvider {
           }
           processedResourceIds.add(resourceId);
           results.push({
-            error: SyncBlockError.Errored,
+            error: mapErrorResponseCode(errorResponse.code),
             resourceId
           });
         }
       }
 
       // Ensure all resourceIds have a result - return NotFound for any missing ones
-      for (const resourceId of resourceIds) {
-        if (!processedResourceIds.has(resourceId)) {
+      for (const blockNodeIdentifier of blockNodeIdentifiers) {
+        if (!processedResourceIds.has(blockNodeIdentifier.resourceId)) {
           results.push({
             error: SyncBlockError.NotFound,
-            resourceId
+            resourceId: blockNodeIdentifier.resourceId
           });
         }
       }
       return results;
     } catch (error) {
       // If batch request fails, return error for all resourceIds
-      return resourceIds.map(resourceId => ({
+      return blockNodeIdentifiers.map(blockNodeIdentifier => ({
         error: error instanceof BlockError ? mapBlockError(error) : SyncBlockError.Errored,
-        resourceId
+        resourceId: blockNodeIdentifier.resourceId
       }));
     }
   }