@atlaskit/editor-synced-block-provider 2.7.4 → 2.8.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @atlaskit/editor-synced-block-provider
 
+## 2.8.0
+
+### Minor Changes
+
+- [`ec416ddf3747c`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/ec416ddf3747c) -
+  Add a block service API provider
+
 ## 2.7.4
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -93,6 +93,12 @@ Object.defineProperty(exports, "useHandleContentChanges", {
     return _useHandleContentChanges.useHandleContentChanges;
   }
 });
+Object.defineProperty(exports, "useMemoizedBlockServiceAPIProviders", {
+  enumerable: true,
+  get: function get() {
+    return _blockServiceAPI.useMemoizedBlockServiceAPIProviders;
+  }
+});
 Object.defineProperty(exports, "useMemoizedContentAPIProviders", {
   enumerable: true,
   get: function get() {
@@ -110,6 +116,7 @@ var _types = require("./common/types");
 var _useFetchSyncBlockData = require("./hooks/useFetchSyncBlockData");
 var _useFetchSyncBlockTitle = require("./hooks/useFetchSyncBlockTitle");
 var _useHandleContentChanges = require("./hooks/useHandleContentChanges");
+var _blockServiceAPI = require("./providers/block-service/blockServiceAPI");
 var _confluenceContentAPI = require("./providers/confluence/confluenceContentAPI");
 var _syncBlockProvider = require("./providers/syncBlockProvider");
 var _referenceSyncBlockStoreManager = require("./store-manager/referenceSyncBlockStoreManager");

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

@@ -0,0 +1,232 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMemoizedBlockServiceAPIProviders = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+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 _react = require("react");
+var _types = require("../../common/types");
+var _ari = require("../../utils/ari");
+var _blockService = require("../../utils/blockService");
+var _errorHandling = require("../../utils/errorHandling");
+var mapBlockError = function mapBlockError(error) {
+  switch (error.status) {
+    case 403:
+      return _types.SyncBlockError.Forbidden;
+    case 404:
+      return _types.SyncBlockError.NotFound;
+  }
+  return _types.SyncBlockError.Errored;
+};
+
+/**
+ * ADFFetchProvider implementation that fetches synced block data from Block Service API
+ */
+var BlockServiceADFFetchProvider = /*#__PURE__*/function () {
+  function BlockServiceADFFetchProvider() {
+    (0, _classCallCheck2.default)(this, BlockServiceADFFetchProvider);
+  }
+  return (0, _createClass2.default)(BlockServiceADFFetchProvider, [{
+    key: "fetchData",
+    value: // resourceId is the ARI of the block. E.G ari:cloud:blocks:site-123:synced-block/uuid-456
+    function () {
+      var _fetchData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(resourceId) {
+        var localId, contentProperty, value, syncedBlockData;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              localId = (0, _ari.getLocalIdFromAri)(resourceId);
+              _context.prev = 1;
+              _context.next = 4;
+              return (0, _blockService.getSyncedBlockContent)({
+                blockAri: resourceId
+              });
+            case 4:
+              contentProperty = _context.sent;
+              value = contentProperty.content;
+              if (value) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", {
+                error: _types.SyncBlockError.NotFound,
+                resourceId: resourceId
+              });
+            case 8:
+              // Parse the synced block content from the property value
+              syncedBlockData = JSON.parse(value);
+              return _context.abrupt("return", {
+                data: {
+                  content: syncedBlockData,
+                  resourceId: resourceId,
+                  blockInstanceId: localId
+                },
+                resourceId: resourceId
+              });
+            case 12:
+              _context.prev = 12;
+              _context.t0 = _context["catch"](1);
+              if (!(_context.t0 instanceof _blockService.BlockError)) {
+                _context.next = 16;
+                break;
+              }
+              return _context.abrupt("return", {
+                error: mapBlockError(_context.t0),
+                resourceId: resourceId
+              });
+            case 16:
+              return _context.abrupt("return", {
+                error: _types.SyncBlockError.Errored,
+                resourceId: resourceId
+              });
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 12]]);
+      }));
+      function fetchData(_x) {
+        return _fetchData.apply(this, arguments);
+      }
+      return fetchData;
+    }()
+  }]);
+}();
+/**
+ * ADFWriteProvider implementation that writes synced block data to Block Service API
+ */
+var BlockServiceADFWriteProvider = /*#__PURE__*/function () {
+  function BlockServiceADFWriteProvider() {
+    (0, _classCallCheck2.default)(this, BlockServiceADFWriteProvider);
+  }
+  return (0, _createClass2.default)(BlockServiceADFWriteProvider, [{
+    key: "writeData",
+    value: // it will first try to update and if it can't (404) then it will try to create 
+    function () {
+      var _writeData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(data) {
+        var resourceId;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              resourceId = data.resourceId;
+              _context2.prev = 1;
+              _context2.next = 4;
+              return (0, _blockService.updateSyncedBlock)({
+                blockAri: resourceId,
+                content: JSON.stringify(data.content)
+              });
+            case 4:
+              return _context2.abrupt("return", {
+                resourceId: resourceId
+              });
+            case 7:
+              _context2.prev = 7;
+              _context2.t0 = _context2["catch"](1);
+              if (!(_context2.t0 instanceof _blockService.BlockError)) {
+                _context2.next = 16;
+                break;
+              }
+              if (!(_context2.t0.status === 404)) {
+                _context2.next = 15;
+                break;
+              }
+              _context2.next = 13;
+              return (0, _blockService.createSyncedBlock)({
+                blockAri: (0, _ari.resourceIdFromSourceAndLocalId)(resourceId, data.blockInstanceId),
+                blockInstanceId: data.blockInstanceId,
+                sourceAri: resourceId,
+                product: 'confluence-page',
+                content: JSON.stringify(data.content)
+              });
+            case 13:
+              _context2.next = 16;
+              break;
+            case 15:
+              return _context2.abrupt("return", {
+                error: mapBlockError(_context2.t0),
+                resourceId: resourceId
+              });
+            case 16:
+              return _context2.abrupt("return", {
+                error: (0, _errorHandling.stringifyError)(_context2.t0),
+                resourceId: resourceId
+              });
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[1, 7]]);
+      }));
+      function writeData(_x2) {
+        return _writeData.apply(this, arguments);
+      }
+      return writeData;
+    }() // soft deletes the source synced block 
+  }, {
+    key: "deleteData",
+    value: function () {
+      var _deleteData = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(resourceId) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return (0, _blockService.deleteSyncedBlock)({
+                blockAri: resourceId
+              });
+            case 3:
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: true,
+                error: undefined
+              });
+            case 6:
+              _context3.prev = 6;
+              _context3.t0 = _context3["catch"](0);
+              if (!(_context3.t0 instanceof _blockService.BlockError)) {
+                _context3.next = 10;
+                break;
+              }
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: false,
+                error: mapBlockError(_context3.t0)
+              });
+            case 10:
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: false,
+                error: (0, _errorHandling.stringifyError)(_context3.t0)
+              });
+            case 11:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, null, [[0, 6]]);
+      }));
+      function deleteData(_x3) {
+        return _deleteData.apply(this, arguments);
+      }
+      return deleteData;
+    }()
+  }]);
+}();
+/**
+ * Factory function to create both providers with shared configuration
+ */
+var createBlockServiceAPIProviders = function createBlockServiceAPIProviders() {
+  var fetchProvider = new BlockServiceADFFetchProvider();
+  var writeProvider = new BlockServiceADFWriteProvider();
+  return {
+    fetchProvider: fetchProvider,
+    writeProvider: writeProvider
+  };
+};
+var useMemoizedBlockServiceAPIProviders = exports.useMemoizedBlockServiceAPIProviders = function useMemoizedBlockServiceAPIProviders() {
+  return (0, _react.useMemo)(createBlockServiceAPIProviders, []);
+};

package/dist/cjs/utils/blockService.js

@@ -0,0 +1,168 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateSyncedBlock = exports.getSyncedBlockContent = exports.deleteSyncedBlock = exports.createSyncedBlock = exports.BlockError = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var COMMON_HEADERS = {
+  'Content-Type': 'application/json',
+  Accept: 'application/json'
+};
+var BLOCK_SERVICE_API_URL = '/gateway/api/blocks/v1';
+var BlockError = exports.BlockError = /*#__PURE__*/function (_Error) {
+  function BlockError(status) {
+    var _this;
+    (0, _classCallCheck2.default)(this, BlockError);
+    _this = _callSuper(this, BlockError, ["Block error"]);
+    _this.status = status;
+    return _this;
+  }
+  (0, _inherits2.default)(BlockError, _Error);
+  return (0, _createClass2.default)(BlockError);
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+var getSyncedBlockContent = exports.getSyncedBlockContent = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref) {
+    var blockAri, response;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          blockAri = _ref.blockAri;
+          _context.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'GET',
+            headers: COMMON_HEADERS
+          });
+        case 3:
+          response = _context.sent;
+          if (response.ok) {
+            _context.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+          _context.next = 8;
+          return response.json();
+        case 8:
+          return _context.abrupt("return", _context.sent);
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getSyncedBlockContent(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var deleteSyncedBlock = exports.deleteSyncedBlock = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(_ref3) {
+    var blockAri, response;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          blockAri = _ref3.blockAri;
+          _context2.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'DELETE',
+            headers: COMMON_HEADERS
+          });
+        case 3:
+          response = _context2.sent;
+          if (response.ok) {
+            _context2.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function deleteSyncedBlock(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var updateSyncedBlock = exports.updateSyncedBlock = /*#__PURE__*/function () {
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(_ref5) {
+    var blockAri, content, response;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          blockAri = _ref5.blockAri, content = _ref5.content;
+          _context3.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'PUT',
+            headers: COMMON_HEADERS,
+            body: JSON.stringify({
+              content: content
+            })
+          });
+        case 3:
+          response = _context3.sent;
+          if (response.ok) {
+            _context3.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function updateSyncedBlock(_x3) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+var createSyncedBlock = exports.createSyncedBlock = /*#__PURE__*/function () {
+  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(_ref7) {
+    var blockAri, blockInstanceId, sourceAri, product, content, response;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          blockAri = _ref7.blockAri, blockInstanceId = _ref7.blockInstanceId, sourceAri = _ref7.sourceAri, product = _ref7.product, content = _ref7.content;
+          _context4.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'POST',
+            headers: COMMON_HEADERS,
+            body: JSON.stringify({
+              blockInstanceId: blockInstanceId,
+              sourceAri: sourceAri,
+              product: product,
+              content: content
+            })
+          });
+        case 3:
+          response = _context4.sent;
+          if (response.ok) {
+            _context4.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+          _context4.next = 8;
+          return response.json();
+        case 8:
+          return _context4.abrupt("return", _context4.sent);
+        case 9:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return function createSyncedBlock(_x4) {
+    return _ref8.apply(this, arguments);
+  };
+}();

package/dist/es2019/index.js

@@ -5,6 +5,7 @@ export { SyncBlockError } from './common/types';
 export { useFetchSyncBlockData } from './hooks/useFetchSyncBlockData';
 export { useFetchSyncBlockTitle } from './hooks/useFetchSyncBlockTitle';
 export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export { useMemoizedBlockServiceAPIProviders } from './providers/block-service/blockServiceAPI';
 export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders } from './providers/confluence/confluenceContentAPI';
 export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './providers/syncBlockProvider';
 export { ReferenceSyncBlockStoreManager } from './store-manager/referenceSyncBlockStoreManager';

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

@@ -0,0 +1,144 @@
+import { useMemo } from 'react';
+import { SyncBlockError } from '../../common/types';
+import { getLocalIdFromAri, resourceIdFromSourceAndLocalId } from '../../utils/ari';
+import { BlockError, createSyncedBlock, deleteSyncedBlock, getSyncedBlockContent, updateSyncedBlock } from '../../utils/blockService';
+import { stringifyError } from '../../utils/errorHandling';
+const mapBlockError = error => {
+  switch (error.status) {
+    case 403:
+      return SyncBlockError.Forbidden;
+    case 404:
+      return SyncBlockError.NotFound;
+  }
+  return SyncBlockError.Errored;
+};
+
+/**
+ * ADFFetchProvider implementation that fetches synced block data from Block Service API
+ */
+class BlockServiceADFFetchProvider {
+  // resourceId is the ARI of the block. E.G ari:cloud:blocks:site-123:synced-block/uuid-456
+  async fetchData(resourceId) {
+    const localId = getLocalIdFromAri(resourceId);
+    try {
+      const contentProperty = await getSyncedBlockContent({
+        blockAri: resourceId
+      });
+      const value = contentProperty.content;
+      if (!value) {
+        return {
+          error: SyncBlockError.NotFound,
+          resourceId
+        };
+      }
+
+      // Parse the synced block content from the property value
+      const syncedBlockData = JSON.parse(value);
+      return {
+        data: {
+          content: syncedBlockData,
+          resourceId,
+          blockInstanceId: localId
+        },
+        resourceId
+      };
+    } catch (error) {
+      if (error instanceof BlockError) {
+        return {
+          error: mapBlockError(error),
+          resourceId
+        };
+      }
+      return {
+        error: SyncBlockError.Errored,
+        resourceId
+      };
+    }
+  }
+}
+
+/**
+ * ADFWriteProvider implementation that writes synced block data to Block Service API
+ */
+class BlockServiceADFWriteProvider {
+  // it will first try to update and if it can't (404) then it will try to create 
+  async writeData(data) {
+    const {
+      resourceId
+    } = data;
+    try {
+      // Try update existing block's content
+      await updateSyncedBlock({
+        blockAri: resourceId,
+        content: JSON.stringify(data.content)
+      });
+      return {
+        resourceId
+      };
+    } catch (error) {
+      if (error instanceof BlockError) {
+        if (error.status === 404) {
+          // Create the block
+          await createSyncedBlock({
+            blockAri: resourceIdFromSourceAndLocalId(resourceId, data.blockInstanceId),
+            blockInstanceId: data.blockInstanceId,
+            sourceAri: resourceId,
+            product: 'confluence-page',
+            content: JSON.stringify(data.content)
+          });
+        } else {
+          return {
+            error: mapBlockError(error),
+            resourceId
+          };
+        }
+      }
+      return {
+        error: stringifyError(error),
+        resourceId
+      };
+    }
+  }
+
+  // soft deletes the source synced block 
+  async deleteData(resourceId) {
+    try {
+      await deleteSyncedBlock({
+        blockAri: resourceId
+      });
+      return {
+        resourceId,
+        success: true,
+        error: undefined
+      };
+    } catch (error) {
+      if (error instanceof BlockError) {
+        return {
+          resourceId,
+          success: false,
+          error: mapBlockError(error)
+        };
+      }
+      return {
+        resourceId,
+        success: false,
+        error: stringifyError(error)
+      };
+    }
+  }
+}
+
+/**
+ * Factory function to create both providers with shared configuration
+ */
+const createBlockServiceAPIProviders = () => {
+  const fetchProvider = new BlockServiceADFFetchProvider();
+  const writeProvider = new BlockServiceADFWriteProvider();
+  return {
+    fetchProvider,
+    writeProvider
+  };
+};
+export const useMemoizedBlockServiceAPIProviders = () => {
+  return useMemo(createBlockServiceAPIProviders, []);
+};

package/dist/es2019/utils/blockService.js

@@ -0,0 +1,71 @@
+const COMMON_HEADERS = {
+  'Content-Type': 'application/json',
+  Accept: 'application/json'
+};
+const BLOCK_SERVICE_API_URL = '/gateway/api/blocks/v1';
+export class BlockError extends Error {
+  constructor(status) {
+    super(`Block error`);
+    this.status = status;
+  }
+}
+export const getSyncedBlockContent = async ({
+  blockAri
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'GET',
+    headers: COMMON_HEADERS
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+  return await response.json();
+};
+export const deleteSyncedBlock = async ({
+  blockAri
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'DELETE',
+    headers: COMMON_HEADERS
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+};
+export const updateSyncedBlock = async ({
+  blockAri,
+  content
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'PUT',
+    headers: COMMON_HEADERS,
+    body: JSON.stringify({
+      content
+    })
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+};
+export const createSyncedBlock = async ({
+  blockAri,
+  blockInstanceId,
+  sourceAri,
+  product,
+  content
+}) => {
+  const response = await fetch(`${BLOCK_SERVICE_API_URL}/block/${blockAri}`, {
+    method: 'POST',
+    headers: COMMON_HEADERS,
+    body: JSON.stringify({
+      blockInstanceId,
+      sourceAri,
+      product,
+      content
+    })
+  });
+  if (!response.ok) {
+    throw new BlockError(response.status);
+  }
+  return await response.json();
+};

package/dist/esm/index.js

@@ -5,6 +5,7 @@ export { SyncBlockError } from './common/types';
 export { useFetchSyncBlockData } from './hooks/useFetchSyncBlockData';
 export { useFetchSyncBlockTitle } from './hooks/useFetchSyncBlockTitle';
 export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export { useMemoizedBlockServiceAPIProviders } from './providers/block-service/blockServiceAPI';
 export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders } from './providers/confluence/confluenceContentAPI';
 export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider } from './providers/syncBlockProvider';
 export { ReferenceSyncBlockStoreManager } from './store-manager/referenceSyncBlockStoreManager';

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

@@ -0,0 +1,225 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { useMemo } from 'react';
+import { SyncBlockError } from '../../common/types';
+import { getLocalIdFromAri, resourceIdFromSourceAndLocalId } from '../../utils/ari';
+import { BlockError, createSyncedBlock, deleteSyncedBlock, getSyncedBlockContent, updateSyncedBlock } from '../../utils/blockService';
+import { stringifyError } from '../../utils/errorHandling';
+var mapBlockError = function mapBlockError(error) {
+  switch (error.status) {
+    case 403:
+      return SyncBlockError.Forbidden;
+    case 404:
+      return SyncBlockError.NotFound;
+  }
+  return SyncBlockError.Errored;
+};
+
+/**
+ * ADFFetchProvider implementation that fetches synced block data from Block Service API
+ */
+var BlockServiceADFFetchProvider = /*#__PURE__*/function () {
+  function BlockServiceADFFetchProvider() {
+    _classCallCheck(this, BlockServiceADFFetchProvider);
+  }
+  return _createClass(BlockServiceADFFetchProvider, [{
+    key: "fetchData",
+    value: // resourceId is the ARI of the block. E.G ari:cloud:blocks:site-123:synced-block/uuid-456
+    function () {
+      var _fetchData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(resourceId) {
+        var localId, contentProperty, value, syncedBlockData;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              localId = getLocalIdFromAri(resourceId);
+              _context.prev = 1;
+              _context.next = 4;
+              return getSyncedBlockContent({
+                blockAri: resourceId
+              });
+            case 4:
+              contentProperty = _context.sent;
+              value = contentProperty.content;
+              if (value) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", {
+                error: SyncBlockError.NotFound,
+                resourceId: resourceId
+              });
+            case 8:
+              // Parse the synced block content from the property value
+              syncedBlockData = JSON.parse(value);
+              return _context.abrupt("return", {
+                data: {
+                  content: syncedBlockData,
+                  resourceId: resourceId,
+                  blockInstanceId: localId
+                },
+                resourceId: resourceId
+              });
+            case 12:
+              _context.prev = 12;
+              _context.t0 = _context["catch"](1);
+              if (!(_context.t0 instanceof BlockError)) {
+                _context.next = 16;
+                break;
+              }
+              return _context.abrupt("return", {
+                error: mapBlockError(_context.t0),
+                resourceId: resourceId
+              });
+            case 16:
+              return _context.abrupt("return", {
+                error: SyncBlockError.Errored,
+                resourceId: resourceId
+              });
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 12]]);
+      }));
+      function fetchData(_x) {
+        return _fetchData.apply(this, arguments);
+      }
+      return fetchData;
+    }()
+  }]);
+}();
+/**
+ * ADFWriteProvider implementation that writes synced block data to Block Service API
+ */
+var BlockServiceADFWriteProvider = /*#__PURE__*/function () {
+  function BlockServiceADFWriteProvider() {
+    _classCallCheck(this, BlockServiceADFWriteProvider);
+  }
+  return _createClass(BlockServiceADFWriteProvider, [{
+    key: "writeData",
+    value: // it will first try to update and if it can't (404) then it will try to create 
+    function () {
+      var _writeData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(data) {
+        var resourceId;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              resourceId = data.resourceId;
+              _context2.prev = 1;
+              _context2.next = 4;
+              return updateSyncedBlock({
+                blockAri: resourceId,
+                content: JSON.stringify(data.content)
+              });
+            case 4:
+              return _context2.abrupt("return", {
+                resourceId: resourceId
+              });
+            case 7:
+              _context2.prev = 7;
+              _context2.t0 = _context2["catch"](1);
+              if (!(_context2.t0 instanceof BlockError)) {
+                _context2.next = 16;
+                break;
+              }
+              if (!(_context2.t0.status === 404)) {
+                _context2.next = 15;
+                break;
+              }
+              _context2.next = 13;
+              return createSyncedBlock({
+                blockAri: resourceIdFromSourceAndLocalId(resourceId, data.blockInstanceId),
+                blockInstanceId: data.blockInstanceId,
+                sourceAri: resourceId,
+                product: 'confluence-page',
+                content: JSON.stringify(data.content)
+              });
+            case 13:
+              _context2.next = 16;
+              break;
+            case 15:
+              return _context2.abrupt("return", {
+                error: mapBlockError(_context2.t0),
+                resourceId: resourceId
+              });
+            case 16:
+              return _context2.abrupt("return", {
+                error: stringifyError(_context2.t0),
+                resourceId: resourceId
+              });
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[1, 7]]);
+      }));
+      function writeData(_x2) {
+        return _writeData.apply(this, arguments);
+      }
+      return writeData;
+    }() // soft deletes the source synced block 
+  }, {
+    key: "deleteData",
+    value: function () {
+      var _deleteData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(resourceId) {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return deleteSyncedBlock({
+                blockAri: resourceId
+              });
+            case 3:
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: true,
+                error: undefined
+              });
+            case 6:
+              _context3.prev = 6;
+              _context3.t0 = _context3["catch"](0);
+              if (!(_context3.t0 instanceof BlockError)) {
+                _context3.next = 10;
+                break;
+              }
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: false,
+                error: mapBlockError(_context3.t0)
+              });
+            case 10:
+              return _context3.abrupt("return", {
+                resourceId: resourceId,
+                success: false,
+                error: stringifyError(_context3.t0)
+              });
+            case 11:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, null, [[0, 6]]);
+      }));
+      function deleteData(_x3) {
+        return _deleteData.apply(this, arguments);
+      }
+      return deleteData;
+    }()
+  }]);
+}();
+/**
+ * Factory function to create both providers with shared configuration
+ */
+var createBlockServiceAPIProviders = function createBlockServiceAPIProviders() {
+  var fetchProvider = new BlockServiceADFFetchProvider();
+  var writeProvider = new BlockServiceADFWriteProvider();
+  return {
+    fetchProvider: fetchProvider,
+    writeProvider: writeProvider
+  };
+};
+export var useMemoizedBlockServiceAPIProviders = function useMemoizedBlockServiceAPIProviders() {
+  return useMemo(createBlockServiceAPIProviders, []);
+};

package/dist/esm/utils/blockService.js

@@ -0,0 +1,161 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var COMMON_HEADERS = {
+  'Content-Type': 'application/json',
+  Accept: 'application/json'
+};
+var BLOCK_SERVICE_API_URL = '/gateway/api/blocks/v1';
+export var BlockError = /*#__PURE__*/function (_Error) {
+  function BlockError(status) {
+    var _this;
+    _classCallCheck(this, BlockError);
+    _this = _callSuper(this, BlockError, ["Block error"]);
+    _this.status = status;
+    return _this;
+  }
+  _inherits(BlockError, _Error);
+  return _createClass(BlockError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var getSyncedBlockContent = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+    var blockAri, response;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          blockAri = _ref.blockAri;
+          _context.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'GET',
+            headers: COMMON_HEADERS
+          });
+        case 3:
+          response = _context.sent;
+          if (response.ok) {
+            _context.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+          _context.next = 8;
+          return response.json();
+        case 8:
+          return _context.abrupt("return", _context.sent);
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getSyncedBlockContent(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export var deleteSyncedBlock = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref3) {
+    var blockAri, response;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          blockAri = _ref3.blockAri;
+          _context2.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'DELETE',
+            headers: COMMON_HEADERS
+          });
+        case 3:
+          response = _context2.sent;
+          if (response.ok) {
+            _context2.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function deleteSyncedBlock(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+export var updateSyncedBlock = /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref5) {
+    var blockAri, content, response;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          blockAri = _ref5.blockAri, content = _ref5.content;
+          _context3.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'PUT',
+            headers: COMMON_HEADERS,
+            body: JSON.stringify({
+              content: content
+            })
+          });
+        case 3:
+          response = _context3.sent;
+          if (response.ok) {
+            _context3.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function updateSyncedBlock(_x3) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+export var createSyncedBlock = /*#__PURE__*/function () {
+  var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref7) {
+    var blockAri, blockInstanceId, sourceAri, product, content, response;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          blockAri = _ref7.blockAri, blockInstanceId = _ref7.blockInstanceId, sourceAri = _ref7.sourceAri, product = _ref7.product, content = _ref7.content;
+          _context4.next = 3;
+          return fetch("".concat(BLOCK_SERVICE_API_URL, "/block/").concat(blockAri), {
+            method: 'POST',
+            headers: COMMON_HEADERS,
+            body: JSON.stringify({
+              blockInstanceId: blockInstanceId,
+              sourceAri: sourceAri,
+              product: product,
+              content: content
+            })
+          });
+        case 3:
+          response = _context4.sent;
+          if (response.ok) {
+            _context4.next = 6;
+            break;
+          }
+          throw new BlockError(response.status);
+        case 6:
+          _context4.next = 8;
+          return response.json();
+        case 8:
+          return _context4.abrupt("return", _context4.sent);
+        case 9:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return function createSyncedBlock(_x4) {
+    return _ref8.apply(this, arguments);
+  };
+}();

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ export type { SyncBlockData, SyncBlockNode } from './common/types';
 export { useFetchSyncBlockData, type UseFetchSyncBlockDataResult, } from './hooks/useFetchSyncBlockData';
 export { useFetchSyncBlockTitle } from './hooks/useFetchSyncBlockTitle';
 export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export { useMemoizedBlockServiceAPIProviders } from './providers/block-service/blockServiceAPI';
 export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders, } from './providers/confluence/confluenceContentAPI';
 export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider, } from './providers/syncBlockProvider';
 export type { ADFFetchProvider, ADFWriteProvider, SyncBlockDataProvider, SyncBlockInstance, } from './providers/types';

package/dist/types/providers/block-service/blockServiceAPI.d.ts

@@ -0,0 +1,20 @@
+import { type SyncBlockData } from '../../common/types';
+import type { ADFFetchProvider, ADFWriteProvider, DeleteSyncBlockResult, SyncBlockInstance, WriteSyncBlockResult } from '../types';
+/**
+ * ADFFetchProvider implementation that fetches synced block data from Block Service API
+ */
+declare class BlockServiceADFFetchProvider implements ADFFetchProvider {
+    fetchData(resourceId: string): Promise<SyncBlockInstance>;
+}
+/**
+ * ADFWriteProvider implementation that writes synced block data to Block Service API
+ */
+declare class BlockServiceADFWriteProvider implements ADFWriteProvider {
+    writeData(data: SyncBlockData): Promise<WriteSyncBlockResult>;
+    deleteData(resourceId: string): Promise<DeleteSyncBlockResult>;
+}
+export declare const useMemoizedBlockServiceAPIProviders: () => {
+    fetchProvider: BlockServiceADFFetchProvider;
+    writeProvider: BlockServiceADFWriteProvider;
+};
+export {};

package/dist/types/utils/blockService.d.ts

@@ -0,0 +1,39 @@
+export type BlockProduct = 'confluence-page' | 'jira-work-item';
+export type BlockContentResponse = {
+    blockAri: string;
+    blockInstanceId: string;
+    content: string;
+    contentUpdatedAt: number;
+    createdAt: number;
+    createdBy: string;
+    isSynced: boolean;
+    product: BlockProduct;
+    sourceAri: string;
+    status: 'active' | 'deleted';
+    version: number;
+};
+export type GetSyncedBlockContentRequest = {
+    blockAri: string;
+};
+export type DeleteSyncedBlockRequest = {
+    blockAri: string;
+};
+export type UpdateSyncedBlockRequest = {
+    blockAri: string;
+    content: string;
+};
+export type CreateSyncedBlockRequest = {
+    blockAri: string;
+    blockInstanceId: string;
+    content: string;
+    product: string;
+    sourceAri: string;
+};
+export declare class BlockError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare const getSyncedBlockContent: ({ blockAri, }: GetSyncedBlockContentRequest) => Promise<BlockContentResponse>;
+export declare const deleteSyncedBlock: ({ blockAri, }: DeleteSyncedBlockRequest) => Promise<void>;
+export declare const updateSyncedBlock: ({ blockAri, content, }: UpdateSyncedBlockRequest) => Promise<void>;
+export declare const createSyncedBlock: ({ blockAri, blockInstanceId, sourceAri, product, content, }: CreateSyncedBlockRequest) => Promise<BlockContentResponse>;

package/dist/types-ts4.5/index.d.ts

@@ -4,6 +4,7 @@ export type { SyncBlockData, SyncBlockNode } from './common/types';
 export { useFetchSyncBlockData, type UseFetchSyncBlockDataResult, } from './hooks/useFetchSyncBlockData';
 export { useFetchSyncBlockTitle } from './hooks/useFetchSyncBlockTitle';
 export { useHandleContentChanges } from './hooks/useHandleContentChanges';
+export { useMemoizedBlockServiceAPIProviders } from './providers/block-service/blockServiceAPI';
 export { createContentAPIProvidersWithDefaultKey, useMemoizedContentAPIProviders, } from './providers/confluence/confluenceContentAPI';
 export { SyncBlockProvider as SyncedBlockProvider, useMemoizedSyncedBlockProvider, } from './providers/syncBlockProvider';
 export type { ADFFetchProvider, ADFWriteProvider, SyncBlockDataProvider, SyncBlockInstance, } from './providers/types';

package/dist/types-ts4.5/providers/block-service/blockServiceAPI.d.ts

@@ -0,0 +1,20 @@
+import { type SyncBlockData } from '../../common/types';
+import type { ADFFetchProvider, ADFWriteProvider, DeleteSyncBlockResult, SyncBlockInstance, WriteSyncBlockResult } from '../types';
+/**
+ * ADFFetchProvider implementation that fetches synced block data from Block Service API
+ */
+declare class BlockServiceADFFetchProvider implements ADFFetchProvider {
+    fetchData(resourceId: string): Promise<SyncBlockInstance>;
+}
+/**
+ * ADFWriteProvider implementation that writes synced block data to Block Service API
+ */
+declare class BlockServiceADFWriteProvider implements ADFWriteProvider {
+    writeData(data: SyncBlockData): Promise<WriteSyncBlockResult>;
+    deleteData(resourceId: string): Promise<DeleteSyncBlockResult>;
+}
+export declare const useMemoizedBlockServiceAPIProviders: () => {
+    fetchProvider: BlockServiceADFFetchProvider;
+    writeProvider: BlockServiceADFWriteProvider;
+};
+export {};

package/dist/types-ts4.5/utils/blockService.d.ts

@@ -0,0 +1,39 @@
+export type BlockProduct = 'confluence-page' | 'jira-work-item';
+export type BlockContentResponse = {
+    blockAri: string;
+    blockInstanceId: string;
+    content: string;
+    contentUpdatedAt: number;
+    createdAt: number;
+    createdBy: string;
+    isSynced: boolean;
+    product: BlockProduct;
+    sourceAri: string;
+    status: 'active' | 'deleted';
+    version: number;
+};
+export type GetSyncedBlockContentRequest = {
+    blockAri: string;
+};
+export type DeleteSyncedBlockRequest = {
+    blockAri: string;
+};
+export type UpdateSyncedBlockRequest = {
+    blockAri: string;
+    content: string;
+};
+export type CreateSyncedBlockRequest = {
+    blockAri: string;
+    blockInstanceId: string;
+    content: string;
+    product: string;
+    sourceAri: string;
+};
+export declare class BlockError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare const getSyncedBlockContent: ({ blockAri, }: GetSyncedBlockContentRequest) => Promise<BlockContentResponse>;
+export declare const deleteSyncedBlock: ({ blockAri, }: DeleteSyncedBlockRequest) => Promise<void>;
+export declare const updateSyncedBlock: ({ blockAri, content, }: UpdateSyncedBlockRequest) => Promise<void>;
+export declare const createSyncedBlock: ({ blockAri, blockInstanceId, sourceAri, product, content, }: CreateSyncedBlockRequest) => Promise<BlockContentResponse>;

package/package.json

@@ -25,7 +25,7 @@
 	"atlaskit:src": "src/index.ts",
 	"dependencies": {
 		"@atlaskit/adf-schema": "^51.3.2",
-		"@atlaskit/adf-utils": "^19.25.0",
+		"@atlaskit/adf-utils": "^19.26.0",
 		"@atlaskit/css": "^0.15.0",
 		"@atlaskit/editor-json-transformer": "^8.31.0",
 		"@atlaskit/editor-prosemirror": "7.0.0",
@@ -82,7 +82,7 @@
 		}
 	},
 	"name": "@atlaskit/editor-synced-block-provider",
-	"version": "2.7.4",
+	"version": "2.8.0",
 	"description": "Synced Block Provider for @atlaskit/editor-plugin-synced-block",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",