@atlaskit/editor-synced-block-provider 3.2.2 → 3.4.0

package/dist/cjs/providers/syncBlockProvider.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useMemoizedSyncedBlockProvider = exports.createAndInitializeSyncedBlockProvider = exports.SyncBlockProvider = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 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"));
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
@@ -15,6 +15,7 @@ var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/ge
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _react = require("react");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _ari = require("../clients/confluence/ari");
 var _sourceInfo = require("../clients/confluence/sourceInfo");
 var _types = require("../common/types");
@@ -73,7 +74,7 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
     }
 
     /**
-     * Fetch the data from the fetch provider
+     * Fetch the data from the fetch provider using batch API
      *
      * @param nodes
      *
@@ -81,30 +82,66 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
      */
   }, {
     key: "fetchNodesData",
-    value: function fetchNodesData(nodes) {
-      var _this2 = this;
-      var resourceIdSet = new Set(nodes.map(function (node) {
-        return node.attrs.resourceId;
+    value: (function () {
+      var _fetchNodesData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(nodes) {
+        var _this2 = this;
+        var resourceIdSet, resourceIds;
+        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 (!(0, _platformFeatureFlags.fg)('platform_synced_block_dogfooding')) {
+                _context.next = 14;
+                break;
+              }
+              _context.prev = 3;
+              _context.next = 6;
+              return this.fetchProvider.batchFetchData(resourceIds);
+            case 6:
+              return _context.abrupt("return", _context.sent);
+            case 9:
+              _context.prev = 9;
+              _context.t0 = _context["catch"](3);
+              return _context.abrupt("return", resourceIds.map(function (resourceId) {
+                return {
+                  error: _types.SyncBlockError.Errored,
+                  resourceId: resourceId
+                };
+              }));
+            case 12:
+              _context.next = 15;
+              break;
+            case 14:
+              return _context.abrupt("return", Promise.allSettled(resourceIds.map(function (resourceId) {
+                return _this2.fetchProvider.fetchData(resourceId).then(function (data) {
+                  return data;
+                }, function () {
+                  return {
+                    error: _types.SyncBlockError.Errored,
+                    resourceId: resourceId
+                  };
+                });
+              })).then(function (results) {
+                return results.filter(function (result) {
+                  return result.status === 'fulfilled';
+                }).map(function (result) {
+                  return result.value;
+                });
+              }));
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[3, 9]]);
       }));
-      var resourceIds = (0, _toConsumableArray2.default)(resourceIdSet);
-      return Promise.allSettled(resourceIds.map(function (resourceId) {
-        return _this2.fetchProvider.fetchData(resourceId).then(function (data) {
-          return data;
-        }, function () {
-          return {
-            error: _types.SyncBlockError.Errored,
-            resourceId: resourceId
-          };
-        });
-      })).then(function (results) {
-        return results.filter(function (result) {
-          return result.status === 'fulfilled';
-        }).map(function (result) {
-          return result.value;
-        });
-      });
-    }
-
+      function fetchNodesData(_x) {
+        return _fetchNodesData.apply(this, arguments);
+      }
+      return fetchNodesData;
+    }()
     /**
      * Write the data to the write provider
      *
@@ -114,22 +151,23 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
      * @returns Array of {resourceId?: string, error?: string}.
      * resourceId: resource id of the node if write successfully , error: reason for when write failed
      */
+    )
   }, {
     key: "writeNodesData",
     value: (function () {
-      var _writeNodesData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(nodes, data) {
+      var _writeNodesData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(nodes, data) {
         var _this3 = this;
         var results;
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
             case 0:
               if (this.writeProvider) {
-                _context.next = 2;
+                _context2.next = 2;
                 break;
               }
-              return _context.abrupt("return", Promise.reject(new Error('Write provider not set')));
+              return _context2.abrupt("return", Promise.reject(new Error('Write provider not set')));
             case 2:
-              _context.next = 4;
+              _context2.next = 4;
               return Promise.allSettled(nodes.map(function (_node, index) {
                 var _this3$writeProvider;
                 if (!_this3.writeProvider) {
@@ -141,8 +179,8 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
                 return (_this3$writeProvider = _this3.writeProvider) === null || _this3$writeProvider === void 0 ? void 0 : _this3$writeProvider.writeData(data[index]);
               }));
             case 4:
-              results = _context.sent;
-              return _context.abrupt("return", results.map(function (result) {
+              results = _context2.sent;
+              return _context2.abrupt("return", results.map(function (result) {
                 if (result.status === 'fulfilled') {
                   return result.value;
                 } else {
@@ -153,11 +191,11 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
               }));
             case 6:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
-        }, _callee, this);
+        }, _callee2, this);
       }));
-      function writeNodesData(_x, _x2) {
+      function writeNodesData(_x2, _x3) {
         return _writeNodesData.apply(this, arguments);
       }
       return writeNodesData;
@@ -187,19 +225,19 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
   }, {
     key: "deleteNodesData",
     value: (function () {
-      var _deleteNodesData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(resourceIds) {
+      var _deleteNodesData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(resourceIds) {
         var _this4 = this;
         var results;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
               if (this.writeProvider) {
-                _context2.next = 2;
+                _context3.next = 2;
                 break;
               }
-              return _context2.abrupt("return", Promise.reject(new Error('Write provider not set')));
+              return _context3.abrupt("return", Promise.reject(new Error('Write provider not set')));
             case 2:
-              _context2.next = 4;
+              _context3.next = 4;
               return Promise.allSettled(resourceIds.map(function (resourceId) {
                 if (!_this4.writeProvider) {
                   return Promise.reject('Write provider not set');
@@ -207,8 +245,8 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
                 return _this4.writeProvider.deleteData(resourceId);
               }));
             case 4:
-              results = _context2.sent;
-              return _context2.abrupt("return", results.map(function (result, index) {
+              results = _context3.sent;
+              return _context3.abrupt("return", results.map(function (result, index) {
                 if (result.status === 'fulfilled') {
                   return result.value;
                 } else {
@@ -221,11 +259,11 @@ var SyncBlockProvider = exports.SyncBlockProvider = /*#__PURE__*/function (_Sync
               }));
             case 6:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
-      function deleteNodesData(_x3) {
+      function deleteNodesData(_x4) {
         return _deleteNodesData.apply(this, arguments);
       }
       return deleteNodesData;

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

@@ -111,6 +111,30 @@ export const getSyncedBlockContent = async ({
   }
   return await response.json();
 };
+
+/**
+ * Batch retrieves multiple synced blocks by their ARIs.
+ *
+ * Calls the Block Service API endpoint: `POST /v1/block/batch-retrieve`
+ *
+ * @param blockAris - Array of block ARIs to retrieve
+ * @returns A promise containing arrays of successfully fetched blocks and any errors encountered
+ */
+export const batchRetrieveSyncedBlocks = async ({
+  blockAris
+}) => {
+  const response = await fetchWithRetry(`${BLOCK_SERVICE_API_URL}/block/batch-retrieve`, {
+    method: 'POST',
+    headers: COMMON_HEADERS,
+    body: JSON.stringify({
+      blockAris
+    })
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+  return await response.json();
+};
 export const deleteSyncedBlock = async ({
   blockAri
 }) => {

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

@@ -1,7 +1,7 @@
 /* eslint-disable require-unicode-regexp  */
 import { useMemo } from 'react';
 import { generateBlockAri, generateBlockAriFromReference } from '../../clients/block-service/ari';
-import { BlockError, createSyncedBlock, deleteSyncedBlock, getReferenceSyncedBlocks, getSyncedBlockContent, updateReferenceSyncedBlockOnDocument, updateSyncedBlock } from '../../clients/block-service/blockService';
+import { batchRetrieveSyncedBlocks, BlockError, createSyncedBlock, deleteSyncedBlock, getReferenceSyncedBlocks, getSyncedBlockContent, updateReferenceSyncedBlockOnDocument, updateSyncedBlock } from '../../clients/block-service/blockService';
 import { SyncBlockError } from '../../common/types';
 import { stringifyError } from '../../utils/errorHandling';
 const mapBlockError = error => {
@@ -33,10 +33,22 @@ const mapBlockError = error => {
 // - sourceTitle
 // - isSynced
 const convertToSyncBlockData = data => {
+  let createdAt;
+  if (data.createdAt) {
+    try {
+      // BE returns microseconds, convert to milliseconds
+      // BE should fix this in the future
+      createdAt = new Date(data.createdAt / 1000).toISOString();
+    } catch (e) {
+      // fallback to undefined
+      // as we don't want to block the whole process due to invalid date
+      createdAt = undefined;
+    }
+  }
   return {
     blockInstanceId: data.blockInstanceId,
     content: JSON.parse(data.content),
-    createdAt: new Date(data.createdAt).toISOString(),
+    createdAt,
     createdBy: data.createdBy,
     product: data.product,
     resourceId: data.blockAri,
@@ -132,6 +144,110 @@ class BlockServiceADFFetchProvider {
       };
     }
   }
+
+  /**
+   * Extracts the resourceId from a block ARI.
+   * Block ARI format: ari:cloud:blocks:<cloudId>:synced-block/<resourceId>
+   */
+  extractResourceIdFromBlockAri(blockAri) {
+    const match = blockAri.match(/ari:cloud:blocks:[^:]+:synced-block\/(.+)$/);
+    return match === null || match === void 0 ? void 0 : match[1];
+  }
+
+  /**
+   * Batch fetches multiple synced blocks by their resource IDs.
+   * @param resourceIds - Array of resource IDs to fetch
+   * @returns Array of SyncBlockInstance results
+   */
+  async batchFetchData(resourceIds) {
+    const blockAris = resourceIds.map(resourceId => generateBlockAriFromReference({
+      cloudId: this.cloudId,
+      resourceId
+    }));
+
+    // Create a set of valid resourceIds for validation
+    const validResourceIds = new Set(resourceIds);
+
+    // Track which resourceIds have been processed
+    const processedResourceIds = new Set();
+    try {
+      const response = await batchRetrieveSyncedBlocks({
+        blockAris
+      });
+      const results = [];
+
+      // Process successful blocks
+      if (response.success) {
+        for (const blockContentResponse of response.success) {
+          // Extract resourceId from the returned blockAri
+          const resourceId = this.extractResourceIdFromBlockAri(blockContentResponse.blockAri);
+          if (!resourceId || !validResourceIds.has(resourceId)) {
+            continue;
+          }
+          processedResourceIds.add(resourceId);
+          const value = blockContentResponse.content;
+          if (!value) {
+            results.push({
+              error: SyncBlockError.NotFound,
+              resourceId
+            });
+            continue;
+          }
+          try {
+            const syncedBlockData = JSON.parse(value);
+            results.push({
+              data: {
+                content: syncedBlockData,
+                resourceId: blockContentResponse.blockAri,
+                blockInstanceId: blockContentResponse.blockInstanceId,
+                sourceAri: blockContentResponse.sourceAri,
+                product: blockContentResponse.product
+              },
+              resourceId
+            });
+          } catch {
+            results.push({
+              error: SyncBlockError.Errored,
+              resourceId
+            });
+          }
+        }
+      }
+
+      // Process errors
+      if (response.error) {
+        for (const errorResponse of response.error) {
+          // Extract resourceId from the returned blockAri
+          const resourceId = this.extractResourceIdFromBlockAri(errorResponse.blockAri);
+          if (!resourceId || !validResourceIds.has(resourceId)) {
+            continue;
+          }
+          processedResourceIds.add(resourceId);
+          results.push({
+            error: SyncBlockError.Errored,
+            resourceId
+          });
+        }
+      }
+
+      // Ensure all resourceIds have a result - return NotFound for any missing ones
+      for (const resourceId of resourceIds) {
+        if (!processedResourceIds.has(resourceId)) {
+          results.push({
+            error: SyncBlockError.NotFound,
+            resourceId
+          });
+        }
+      }
+      return results;
+    } catch (error) {
+      // If batch request fails, return error for all resourceIds
+      return resourceIds.map(resourceId => ({
+        error: error instanceof BlockError ? mapBlockError(error) : SyncBlockError.Errored,
+        resourceId
+      }));
+    }
+  }
 }
 /**
  * ADFWriteProvider implementation that writes synced block data to Block Service API

package/dist/es2019/providers/syncBlockProvider.js

@@ -1,5 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { useMemo } from 'react';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { getPageIdAndTypeFromConfluencePageAri } from '../clients/confluence/ari';
 import { fetchConfluencePageInfo } from '../clients/confluence/sourceInfo';
 import { SyncBlockError } from '../common/types';
@@ -46,29 +47,41 @@ export class SyncBlockProvider extends SyncBlockDataProvider {
   }
 
   /**
-   * Fetch the data from the fetch provider
+   * Fetch the data from the fetch provider using batch API
    *
    * @param nodes
    *
    * @returns Array of {resourceId?: string, error?: string}.
    */
-  fetchNodesData(nodes) {
+  async fetchNodesData(nodes) {
     const resourceIdSet = new Set(nodes.map(node => node.attrs.resourceId));
     const resourceIds = [...resourceIdSet];
-    return Promise.allSettled(resourceIds.map(resourceId => {
-      return this.fetchProvider.fetchData(resourceId).then(data => {
-        return data;
-      }, () => {
-        return {
+    if (fg('platform_synced_block_dogfooding')) {
+      try {
+        return await this.fetchProvider.batchFetchData(resourceIds);
+      } catch {
+        // If batch fetch fails, return error for all resourceIds
+        return resourceIds.map(resourceId => ({
           error: SyncBlockError.Errored,
           resourceId
-        };
+        }));
+      }
+    } else {
+      return Promise.allSettled(resourceIds.map(resourceId => {
+        return this.fetchProvider.fetchData(resourceId).then(data => {
+          return data;
+        }, () => {
+          return {
+            error: SyncBlockError.Errored,
+            resourceId
+          };
+        });
+      })).then(results => {
+        return results.filter(result => {
+          return result.status === 'fulfilled';
+        }).map(result => result.value);
       });
-    })).then(results => {
-      return results.filter(result => {
-        return result.status === 'fulfilled';
-      }).map(result => result.value);
-    });
+    }
   }
 
   /**