@atlaskit/editor-synced-block-provider 8.1.10 → 8.3.0

package/dist/es2019/utils/errorHandling.js

@@ -58,34 +58,179 @@ export const buildErrorAttribution = (gateEnabled, error, statusCode) => {
   };
 };
 
+/**
+ * The set of categorical failure reasons emitted on synced-block fetch/subscribe
+ * operational error events (EDITOR-7862). Extends the write-path
+ * {@link SyncBlockErrorReason} set with read-path-specific buckets so the analytics
+ * dashboard can break fetch failures down by cause instead of regex-matching the
+ * free-text `error` blob.
+ *
+ * The read path surfaces several causes the write-path `SyncBlockError` enum does not
+ * model (benign source-state transitions, permission denials, WebSocket lifecycle, and
+ * client-side readiness errors), so those are added here. Known `SyncBlockError` enum
+ * values (`not_found`, `forbidden`, ...) still pass through unchanged.
+ */
+
+/**
+ * Fetch reasons that represent benign (working-as-designed) outcomes rather than genuine
+ * system failures. The dashboard uses this to compute a "true error rate" by excluding
+ * benign reasons via the structured `reason` attribute instead of brittle free-text regex
+ * (EDITOR-7862).
+ */
+export const FETCH_BENIGN_REASONS = new Set(['source_deleted', 'source_unpublished', 'source_unsynced', 'source_not_found', 'permission_denied', 'unauthenticated',
+// Mirror the benign write-path enum equivalents so already-classified errors are
+// treated consistently.
+'not_found', 'forbidden', 'unpublished'
+// NOTE: `entity_not_found` and `offline` are intentionally NOT benign.
+// - `entity_not_found` is retried up to ENTITY_NOT_FOUND_MAX_RETRIES (analytics are
+//   suppressed during retries); by the time the error event fires, retries are
+//   exhausted and it is a genuine failure.
+// - `offline` is genuine client connectivity loss, not a working-as-designed outcome.
+// Both still emit `reason` (so they can be inspected) but are counted as true errors.
+]);
+
+/**
+ * Ordered list of substring matchers mapping known free-text fetch/subscribe error
+ * strings to a categorical {@link SyncBlockFetchErrorReason}. Each entry is a list of
+ * lowercase needles; if ANY needle is found (case-insensitively) in the raw `error`
+ * string, the entry's reason is used. Order matters: more specific entries must precede
+ * more general ones.
+ *
+ * Plain `String.includes` substring matching is used deliberately instead of `RegExp`:
+ * it sidesteps the `require-unicode-regexp` lint rule AND the declaration build's lower
+ * compile target (which rejects the regex `u` flag with TS1501), while being faster and
+ * easier to read. Doing this classification in code (rather than in dashboard SQL) keeps
+ * the buckets versioned with the source strings that produce them (EDITOR-7862).
+ */
+const FETCH_REASON_MATCHERS = [
+// Benign: source-state transitions (deletionReason values + free text).
+[['source-document-deleted'], 'source_deleted'], [['source-block-deleted'], 'source_deleted'], [['source-block-unpublished'], 'source_unpublished'], [['source-block-unsynced'], 'source_unsynced'], [['does not exist'], 'source_not_found'], [['unpublished'], 'source_unpublished'],
+// Working-as-designed permission outcomes.
+[['unauthenticated'], 'unauthenticated'], [['not permitted to read synced block'], 'permission_denied'], [['bulk permission check failed'], 'permission_denied'], [['permission denied'], 'permission_denied'],
+// Genuine system failures.
+[['reconnection failed after'], 'websocket_exhausted'],
+// `reconnect to the subscription` (not a bare `reconnect`) avoids false positives on
+// unrelated DB/GraphQL "reconnect" messages while still matching the WS-drop string.
+[['websocket', 'reconnect to the subscription', 'subscription terminated'], 'websocket_drop'], [['429', 'rate limit', 'rate-limit', 'ratelimit'], 'rate_limited'],
+// `econnrefused`/`econnreset` (not a bare `econn`, which would also match `reconnect`).
+[['network', 'failed to fetch', 'econnrefused', 'econnreset', 'timed out', 'timeout'], 'network'], [['data provider not set'], 'data_provider_not_ready']];
+
+/**
+ * Maps a fetch/subscribe `error` field — which may be a {@link SyncBlockError} enum
+ * value, a {@link DeletionReason} value, or an arbitrary free-text/JSON blob — to a
+ * stable categorical {@link SyncBlockFetchErrorReason} for analytics grouping.
+ *
+ * Resolution order:
+ * 1. Known `SyncBlockError` enum value → passed through (via {@link classifyErrorReason}).
+ * 2. Known free-text substring → mapped to a fetch-specific bucket.
+ * 3. Anything else (including opaque blobs like `errored`-only payloads or
+ *    `ErrorEvent: "undefined"`) → `'unknown'`, so the dashboard never groups on free text.
+ *
+ * Note: the bare string `'errored'` IS a `SyncBlockError` enum value and therefore
+ * classifies as `'errored'` (not `'unknown'`); only genuinely unrecognised strings
+ * collapse to `'unknown'`.
+ */
+export const classifyFetchErrorReason = error => {
+  const enumReason = classifyErrorReason(error);
+  if (enumReason !== 'unknown') {
+    return enumReason;
+  }
+  if (error) {
+    const haystack = error.toLowerCase();
+    for (const [needles, reason] of FETCH_REASON_MATCHERS) {
+      if (needles.some(needle => haystack.includes(needle))) {
+        return reason;
+      }
+    }
+  }
+  return 'unknown';
+};
+
+/**
+ * Extra, optional analytics attributes describing WHY a fetch/subscribe synced-block
+ * action failed. Spread conditionally so we never emit `undefined` keys (EDITOR-7862).
+ *
+ * Adds `benign` on top of the shared {@link ErrorAttributionAttributes} so the dashboard
+ * can compute a true error rate (`genuine / total`) without any free-text regex.
+ */
+
+/**
+ * Builds the {@link FetchErrorAttributionAttributes} for a failed fetch/subscribe
+ * synced-block operation from the raw `error` field and optional backend `statusCode`.
+ * Returns `undefined` when the `platform_editor_blocks_patch_3` gate is OFF, so the new
+ * `reason`/`statusCode`/`benign` attributes are only emitted once the gate is rolled out
+ * (EDITOR-7862). The existing free-text `error` attribute is always left unchanged.
+ *
+ * `gateEnabled` is injected by the caller (the store managers evaluate `fg(...)`) so this
+ * helper stays pure and trivially unit-testable for both gate states.
+ */
+export const buildFetchErrorAttribution = (gateEnabled, error, statusCode) => {
+  if (!gateEnabled) {
+    return undefined;
+  }
+  const reason = classifyFetchErrorReason(error);
+  return {
+    reason,
+    benign: FETCH_BENIGN_REASONS.has(reason),
+    ...(statusCode !== undefined && {
+      statusCode
+    })
+  };
+};
+
 // `sourceProduct` is threaded through every helper so analytics
 // events can be attributed to the source product (`confluence-page` vs `jira-work-item`).
 // All helpers accept it as an optional trailing argument; the spread-only-when-truthy
 // pattern below ensures we never emit `sourceProduct: undefined` (which would dirty the
 // event schema with empty keys).
 
-export const getErrorPayload = (actionSubjectId, error, resourceId, sourceProduct, attribution) => ({
-  action: ACTION.ERROR,
-  actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
-  actionSubjectId,
-  eventType: EVENT_TYPE.OPERATIONAL,
-  attributes: {
-    error,
-    ...(resourceId && {
-      resourceId
-    }),
-    ...(sourceProduct && {
-      sourceProduct
-    }),
-    ...((attribution === null || attribution === void 0 ? void 0 : attribution.reason) && {
-      reason: attribution.reason
-    }),
-    ...((attribution === null || attribution === void 0 ? void 0 : attribution.statusCode) !== undefined && {
-      statusCode: attribution.statusCode
-    })
-  }
-});
-export const fetchErrorPayload = (error, resourceId, sourceProduct) => getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH, error, resourceId, sourceProduct);
+/**
+ * Shared operational ERROR payload builder for synced-block events.
+ *
+ * Overloaded so the emitted `reason` type stays accurate per path (raised in review on
+ * EDITOR-7862): fetch/subscribe callers pass a {@link FetchErrorAttributionAttributes}
+ * (discriminated by its required `benign` field) and get the wider
+ * {@link SyncBlockFetchErrorReason}; write-path callers pass an
+ * {@link ErrorAttributionAttributes} (or nothing) and keep the narrower
+ * {@link SyncBlockErrorReason}, so write-path payloads never claim to carry fetch-only
+ * buckets like `source_deleted` they never emit.
+ */
+
+export function getErrorPayload(actionSubjectId, error, resourceId, sourceProduct, attribution) {
+  return {
+    action: ACTION.ERROR,
+    actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
+    actionSubjectId,
+    eventType: EVENT_TYPE.OPERATIONAL,
+    attributes: {
+      error,
+      ...(resourceId && {
+        resourceId
+      }),
+      ...(sourceProduct && {
+        sourceProduct
+      }),
+      ...((attribution === null || attribution === void 0 ? void 0 : attribution.reason) && {
+        reason: attribution.reason
+      }),
+      ...((attribution === null || attribution === void 0 ? void 0 : attribution.statusCode) !== undefined && {
+        statusCode: attribution.statusCode
+      }),
+      // `benign` is only present on fetch/subscribe attribution (EDITOR-7862). It is a
+      // boolean (never UGC); the `'benign' in attribution` check both guards the
+      // write-path attribution (which has no `benign`) and narrows the union so
+      // `attribution.benign` is accessible.
+      ...(attribution && 'benign' in attribution && {
+        benign: attribution.benign
+      })
+    }
+  };
+}
+export const fetchErrorPayload = (error, resourceId, sourceProduct, attribution) =>
+// Branch on attribution presence so each call resolves to a concrete overload: with
+// attribution it hits the fetch overload (wider `reason`); without it (gate OFF) it
+// hits the no-attribution overload. Both produce a fetch event regardless.
+attribution ? getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH, error, resourceId, sourceProduct, attribution) : getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH, error, resourceId, sourceProduct);
 export const getSourceInfoErrorPayload = (error, resourceId, sourceProduct) => getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_GET_SOURCE_INFO, error, resourceId, sourceProduct);
 export const updateErrorPayload = (error, resourceId, sourceProduct, attribution) => getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_UPDATE, error, resourceId, sourceProduct, attribution);
 export const updateReferenceErrorPayload = (error, resourceId, sourceProduct, attribution) => getErrorPayload(ACTION_SUBJECT_ID.REFERENCE_SYNCED_BLOCK_UPDATE, error, resourceId, sourceProduct, attribution);

package/dist/esm/common/types.js

@@ -1,3 +1,13 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+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 _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; })(); }
 export var SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
   SyncBlockError["Errored"] = "errored";
   SyncBlockError["NotFound"] = "not_found";
@@ -16,4 +26,55 @@ export var SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
   // block does not exist on this site (e.g. cross-site reference or hard deleted)
   SyncBlockError["EntityNotFound"] = "entity_not_found";
   return SyncBlockError;
-}({});
+}({});
+/**
+ * Helpers to distinguish "data provider not ready / torn down" from a genuine
+ * fetch/subscribe failure (EDITOR-7860). On Jira the provider is wired
+ * asynchronously and `destroy()` nulls it on orphaned managers, so queued/
+ * in-flight ops throw `Data provider not set` — previously mis-logged as a real
+ * error. These let throw and catch sites agree on one non-string-matched signal
+ * so the residual false errors are suppressed. Gated by
+ * `platform_editor_blocks_patch_3`.
+ *
+ * NB: these intentionally live here rather than in a dedicated module to avoid
+ * adding a downstream file to consuming Jira packages' Thunderstone complexity.
+ */
+
+/** Legacy message — kept identical for gate-off and historical events. */
+export var PROVIDER_NOT_READY_MESSAGE = 'Data provider not set';
+
+/**
+ * Thrown when a fetch/subscribe runs against a manager whose provider is not
+ * (yet) available or torn down. Keeps the legacy message + name so string
+ * matchers still work, while new code uses {@link isProviderNotReadyError}.
+ */
+export var ProviderNotReadyError = /*#__PURE__*/function (_Error) {
+  function ProviderNotReadyError() {
+    var _this;
+    var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : PROVIDER_NOT_READY_MESSAGE;
+    _classCallCheck(this, ProviderNotReadyError);
+    _this = _callSuper(this, ProviderNotReadyError, [message]);
+    _defineProperty(_this, "isProviderNotReadyError", true);
+    _this.name = 'ProviderNotReadyError';
+    // Restore prototype chain so instanceof works after transpilation.
+    Object.setPrototypeOf(_this, ProviderNotReadyError.prototype);
+    return _this;
+  }
+  _inherits(ProviderNotReadyError, _Error);
+  return _createClass(ProviderNotReadyError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+/**
+ * True when the value is a "provider not ready / torn down" condition, not a
+ * genuine failure. Recognises the tagged {@link ProviderNotReadyError} and the
+ * legacy message (for errors thrown before rollout).
+ */
+export var isProviderNotReadyError = function isProviderNotReadyError(error) {
+  if (error instanceof ProviderNotReadyError) {
+    return true;
+  }
+  if (_typeof(error) === 'object' && error !== null && error.isProviderNotReadyError === true) {
+    return true;
+  }
+  return error instanceof Error && error.message === PROVIDER_NOT_READY_MESSAGE;
+};

package/dist/esm/hooks/useFetchSyncBlockData.js

@@ -7,10 +7,12 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { isSSR } from '@atlaskit/editor-common/core-utils';
 import { logException } from '@atlaskit/editor-common/monitoring';
-import { SyncBlockError } from '../common/types';
-import { fetchErrorPayload } from '../utils/errorHandling';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { isProviderNotReadyError, SyncBlockError } from '../common/types';
+import { buildFetchErrorAttribution, fetchErrorPayload } from '../utils/errorHandling';
 import { createSyncBlockNode, getSourceProductFromResourceIdSafe } from '../utils/utils';
 export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resourceId, localId, fireAnalyticsEvent) {
+  var _manager$referenceMan2, _manager$referenceMan3, _manager$referenceMan4;
   // Initialize both states from a single cache lookup to avoid race conditions.
   // When a block is moved/remounted, the old component's cleanup may clear the cache
   // before or after the new component mounts. By doing a single lookup, we ensure
@@ -34,6 +36,14 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
     syncBlockInstance = _useState2$.syncBlockInstance,
     isLoading = _useState2$.isLoading,
     setFetchState = _useState2[1];
+
+  // On Jira the data provider is wired asynchronously, so the manager can be
+  // constructed with `dataProvider === undefined`. Fetching/subscribing in that
+  // window throws `Data provider not set`, logged as a false fetch error
+  // (EDITOR-7860). Gate on readiness; once the provider resolves a new manager
+  // instance is created so `referenceManager` changes identity and the effect
+  // below re-runs, subscribing exactly once.
+  var isDataProviderReady = fg('platform_editor_blocks_patch_3') ? (_manager$referenceMan2 = (_manager$referenceMan3 = (_manager$referenceMan4 = manager.referenceManager).hasDataProvider) === null || _manager$referenceMan3 === void 0 ? void 0 : _manager$referenceMan3.call(_manager$referenceMan4)) !== null && _manager$referenceMan2 !== void 0 ? _manager$referenceMan2 : false : true;
   var reloadData = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
     var syncBlockNode, _t;
     return _regeneratorRuntime.wrap(function (_context) {
@@ -45,14 +55,20 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
           }
           return _context.abrupt("return");
         case 1:
-          _context.prev = 1;
+          if (isDataProviderReady) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return");
+        case 2:
+          _context.prev = 2;
           syncBlockNode = resourceId && localId ? createSyncBlockNode(localId, resourceId) : null;
           if (syncBlockNode) {
-            _context.next = 2;
+            _context.next = 3;
             break;
           }
           throw new Error('Failed to create sync block node from resourceid and localid');
-        case 2:
+        case 3:
           setFetchState(function (prev) {
             return _objectSpread(_objectSpread({}, prev), {}, {
               isLoading: true
@@ -60,18 +76,29 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
           });
 
           // Fetch sync block data, the `subscribeToSyncBlock` will update the state once data is fetched
-          _context.next = 3;
+          _context.next = 4;
           return manager.referenceManager.fetchSyncBlocksData([syncBlockNode]);
-        case 3:
-          _context.next = 5;
-          break;
         case 4:
-          _context.prev = 4;
-          _t = _context["catch"](1);
+          _context.next = 7;
+          break;
+        case 5:
+          _context.prev = 5;
+          _t = _context["catch"](2);
+          if (!(isProviderNotReadyError(_t) && fg('platform_editor_blocks_patch_3'))) {
+            _context.next = 6;
+            break;
+          }
+          setFetchState(function (prev) {
+            return _objectSpread(_objectSpread({}, prev), {}, {
+              isLoading: true
+            });
+          });
+          return _context.abrupt("return");
+        case 6:
           logException(_t, {
             location: 'editor-synced-block-provider/useFetchSyncBlockData'
           });
-          fireAnalyticsEvent === null || fireAnalyticsEvent === void 0 || fireAnalyticsEvent(fetchErrorPayload(_t.message, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+          fireAnalyticsEvent === null || fireAnalyticsEvent === void 0 || fireAnalyticsEvent(fetchErrorPayload(_t.message, resourceId, getSourceProductFromResourceIdSafe(resourceId), buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), _t.message)));
 
           // Set error state if fetching fails
           setFetchState({
@@ -84,24 +111,31 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
             isLoading: false
           });
           return _context.abrupt("return");
-        case 5:
+        case 7:
           setFetchState(function (prev) {
             return _objectSpread(_objectSpread({}, prev), {}, {
               isLoading: false
             });
           });
-        case 6:
+        case 8:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[1, 4]]);
-  })), [isLoading, localId, manager.referenceManager, resourceId, fireAnalyticsEvent]);
+    }, _callee, null, [[2, 5]]);
+  })), [isLoading, isDataProviderReady, localId, manager.referenceManager, resourceId, fireAnalyticsEvent]);
   useEffect(function () {
     if (isSSR()) {
       // in SSR, we don't need to subscribe to updates,
       // instead we rely on pre-fetched data ONLY, see initialization of syncBlockInstance above
       return;
     }
+
+    // Not ready: skip subscribe (it would trigger a batched fetch and a false
+    // error) and keep `isLoading: true`. `isDataProviderReady` is in the deps,
+    // so the effect re-runs and subscribes once the provider resolves.
+    if (!isDataProviderReady) {
+      return;
+    }
     var unsubscribe = manager.referenceManager.subscribeToSyncBlock(resourceId || '', localId || '', function (data) {
       setFetchState({
         syncBlockInstance: data,
@@ -111,7 +145,7 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
     return function () {
       unsubscribe();
     };
-  }, [localId, manager.referenceManager, resourceId]);
+  }, [isDataProviderReady, localId, manager.referenceManager, resourceId]);
   var ssrProviders = useMemo(function () {
     return resourceId ? manager.referenceManager.getSSRProviders(resourceId) : null;
   }, [resourceId, manager.referenceManager]);

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

@@ -1,6 +1,6 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -405,10 +405,12 @@ var _batchFetchData = /*#__PURE__*/function () {
         case 21:
           return _context2.abrupt("return", blockNodeIdentifiers.map(function (blockNodeIdentifier) {
             return {
-              error: {
+              error: _objectSpread({
                 type: _t4 instanceof BlockError ? mapBlockError(_t4) : SyncBlockError.Errored,
                 reason: _t4.message
-              },
+              }, _t4 instanceof BlockError && {
+                statusCode: _t4.status
+              }),
               resourceId: blockNodeIdentifier.resourceId
             };
           }));
@@ -661,7 +663,8 @@ var BlockServiceADFFetchProvider = /*#__PURE__*/function () {
               return _context5.abrupt("return", {
                 error: {
                   type: mapBlockError(_t7),
-                  reason: _t7.message
+                  reason: _t7.message,
+                  statusCode: _t7.status
                 },
                 resourceId: resourceId
               });

package/dist/esm/store-manager/referenceSyncBlockStoreManager.js

@@ -12,8 +12,8 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import isEqual from 'lodash/isEqual';
 import { logException } from '@atlaskit/editor-common/monitoring';
 import { fg } from '@atlaskit/platform-feature-flags';
-import { SyncBlockError } from '../common/types';
-import { buildErrorAttribution, cacheDeletionForcedPayload, fetchErrorPayload, fetchSuccessPayload, getSourceInfoErrorPayload, sourceInfoOrphanedPayload, updateReferenceErrorPayload } from '../utils/errorHandling';
+import { isProviderNotReadyError, ProviderNotReadyError, SyncBlockError } from '../common/types';
+import { buildErrorAttribution, buildFetchErrorAttribution, cacheDeletionForcedPayload, fetchErrorPayload, fetchSuccessPayload, getSourceInfoErrorPayload, sourceInfoOrphanedPayload, updateReferenceErrorPayload } from '../utils/errorHandling';
 import { getFetchExperience, getFetchSourceInfoExperience, getSaveReferenceExperience } from '../utils/experienceTracking';
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 import { createSyncBlockNode, getSourceProductFromResourceIdSafe, normalizeSyncBlockJSONContent } from '../utils/utils';
@@ -121,6 +121,10 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       },
       getFireAnalyticsEvent: function getFireAnalyticsEvent() {
         return _this.fireAnalyticsEvent;
+      },
+      // EDITOR-7860: skip + re-queue fetches while not ready / torn down.
+      isProviderReady: function isProviderReady() {
+        return _this.hasDataProvider();
       }
     });
 
@@ -133,6 +137,19 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       return node.type.name === 'syncBlock';
     }
 
+    /**
+     * Whether the async data provider is wired and the manager is not torn down.
+     * Consumers gate fetch/subscribe on this to avoid a false `Data provider not
+     * set` fetch error (EDITOR-7860). The `isDestroyed` check covers managers
+     * orphaned mid-flight during an async provider swap, where `dataProvider`
+     * alone is insufficient.
+     */
+  }, {
+    key: "hasDataProvider",
+    value: function hasDataProvider() {
+      return !this.isDestroyed && !!this.dataProvider;
+    }
+
     /**
      * Enables or disables real-time GraphQL subscriptions for block updates.
      * When enabled, the store manager will subscribe to real-time updates
@@ -524,22 +541,28 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
               return _context2.abrupt("return");
             case 2:
               if (this.dataProvider) {
+                _context2.next = 4;
+                break;
+              }
+              if (!fg('platform_editor_blocks_patch_3')) {
                 _context2.next = 3;
                 break;
               }
-              throw new Error('Data provider not set');
+              throw new ProviderNotReadyError();
             case 3:
+              throw new Error('Data provider not set');
+            case 4:
               nodesToFetch.forEach(function (node) {
                 _this4.syncBlockFetchDataRequests.set(node.attrs.resourceId, true);
               });
               (_this$fetchExperience6 = this.fetchExperience) === null || _this$fetchExperience6 === void 0 || _this$fetchExperience6.start({});
-              _context2.next = 4;
+              _context2.next = 5;
               return this.dataProvider.fetchNodesData(nodesToFetch).finally(function () {
                 nodesToFetch.forEach(function (node) {
                   _this4.syncBlockFetchDataRequests.delete(node.attrs.resourceId);
                 });
               });
-            case 4:
+            case 5:
               data = _context2.sent;
               _this$processFetchedD2 = this.processFetchedData(data), hasUnexpectedError = _this$processFetchedD2.hasUnexpectedError, hasExpectedError = _this$processFetchedD2.hasExpectedError;
               if (hasUnexpectedError) {
@@ -553,7 +576,7 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
               } else {
                 (_this$fetchExperience9 = this.fetchExperience) === null || _this$fetchExperience9 === void 0 || _this$fetchExperience9.success();
               }
-            case 5:
+            case 6:
             case "end":
               return _context2.stop();
           }
@@ -579,10 +602,12 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       data.forEach(function (syncBlockInstance) {
         var _resolvedSyncBlockIns;
         if (!syncBlockInstance.resourceId) {
-          var _syncBlockInstance$er, _syncBlockInstance$er2, _this5$fireAnalyticsE;
+          var _syncBlockInstance$er, _syncBlockInstance$er2, _this5$fireAnalyticsE, _syncBlockInstance$er3, _syncBlockInstance$er4, _syncBlockInstance$er5;
           var payload = ((_syncBlockInstance$er = syncBlockInstance.error) === null || _syncBlockInstance$er === void 0 ? void 0 : _syncBlockInstance$er.reason) || ((_syncBlockInstance$er2 = syncBlockInstance.error) === null || _syncBlockInstance$er2 === void 0 ? void 0 : _syncBlockInstance$er2.type) || 'Returned sync block instance does not have resource id';
           // No resourceId means we cannot derive a sourceProduct here; intentionally omit.
-          (_this5$fireAnalyticsE = _this5.fireAnalyticsEvent) === null || _this5$fireAnalyticsE === void 0 || _this5$fireAnalyticsE.call(_this5, fetchErrorPayload(payload));
+          // Classify on the structured `type` first, falling back to the free-text
+          // `reason`/payload (EDITOR-7862).
+          (_this5$fireAnalyticsE = _this5.fireAnalyticsEvent) === null || _this5$fireAnalyticsE === void 0 || _this5$fireAnalyticsE.call(_this5, fetchErrorPayload(payload, undefined, undefined, buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), ((_syncBlockInstance$er3 = syncBlockInstance.error) === null || _syncBlockInstance$er3 === void 0 ? void 0 : _syncBlockInstance$er3.type) || ((_syncBlockInstance$er4 = syncBlockInstance.error) === null || _syncBlockInstance$er4 === void 0 ? void 0 : _syncBlockInstance$er4.reason) || payload, (_syncBlockInstance$er5 = syncBlockInstance.error) === null || _syncBlockInstance$er5 === void 0 ? void 0 : _syncBlockInstance$er5.statusCode)));
           return;
         }
         var existingSyncBlock = _this5.getFromCache(syncBlockInstance.resourceId);
@@ -616,7 +641,10 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
           var isRetryingEntityNotFound = syncBlockInstance.error.type === SyncBlockError.EntityNotFound && ((_this5$entityNotFound = _this5.entityNotFoundRetryCount.get(syncBlockInstance.resourceId)) !== null && _this5$entityNotFound !== void 0 ? _this5$entityNotFound : 0) < ENTITY_NOT_FOUND_MAX_RETRIES && fg('platform_synced_block_patch_13');
           if (!isRetryingEntityNotFound) {
             var _this5$fireAnalyticsE2, _syncBlockInstance$da, _syncBlockInstance$da2;
-            (_this5$fireAnalyticsE2 = _this5.fireAnalyticsEvent) === null || _this5$fireAnalyticsE2 === void 0 || _this5$fireAnalyticsE2.call(_this5, fetchErrorPayload(syncBlockInstance.error.reason || syncBlockInstance.error.type, syncBlockInstance.resourceId, (_syncBlockInstance$da = (_syncBlockInstance$da2 = syncBlockInstance.data) === null || _syncBlockInstance$da2 === void 0 ? void 0 : _syncBlockInstance$da2.product) !== null && _syncBlockInstance$da !== void 0 ? _syncBlockInstance$da : getSourceProductFromResourceIdSafe(syncBlockInstance.resourceId)));
+            // Classify on the structured `type` (a `SyncBlockError` enum value) first,
+            // falling back to the free-text `reason` so source-state/permission strings
+            // are still bucketed (EDITOR-7862). The emitted `error` attribute is unchanged.
+            (_this5$fireAnalyticsE2 = _this5.fireAnalyticsEvent) === null || _this5$fireAnalyticsE2 === void 0 || _this5$fireAnalyticsE2.call(_this5, fetchErrorPayload(syncBlockInstance.error.reason || syncBlockInstance.error.type, syncBlockInstance.resourceId, (_syncBlockInstance$da = (_syncBlockInstance$da2 = syncBlockInstance.data) === null || _syncBlockInstance$da2 === void 0 ? void 0 : _syncBlockInstance$da2.product) !== null && _syncBlockInstance$da !== void 0 ? _syncBlockInstance$da : getSourceProductFromResourceIdSafe(syncBlockInstance.resourceId), buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), syncBlockInstance.error.type || syncBlockInstance.error.reason, syncBlockInstance.error.statusCode)));
           }
           if (syncBlockInstance.error.type === SyncBlockError.NotFound || syncBlockInstance.error.type === SyncBlockError.Forbidden) {
             hasExpectedError = true;
@@ -931,10 +959,16 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
         return this._subscriptionManager.subscribeToSyncBlock(resourceId, localId, callback);
       } catch (error) {
         var _this$fireAnalyticsEv7;
+        // EDITOR-7860: benign not-ready/torn-down case — suppress both the
+        // exception-tracker log and the analytics event (checked first so the
+        // benign case stays fully silent). Gate-off behaviour is unchanged.
+        if (isProviderNotReadyError(error) && fg('platform_editor_blocks_patch_3')) {
+          return function () {};
+        }
         logException(error, {
           location: 'editor-synced-block-provider/referenceSyncBlockStoreManager'
         });
-        (_this$fireAnalyticsEv7 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv7 === void 0 || _this$fireAnalyticsEv7.call(this, fetchErrorPayload(error.message));
+        (_this$fireAnalyticsEv7 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv7 === void 0 || _this$fireAnalyticsEv7.call(this, fetchErrorPayload(error.message, undefined, undefined, buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), error.message)));
         return function () {};
       }
     }

package/dist/esm/store-manager/syncBlockBatchFetcher.js

@@ -3,7 +3,9 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import rafSchedule from 'raf-schd';
 import { logException } from '@atlaskit/editor-common/monitoring';
-import { fetchErrorPayload } from '../utils/errorHandling';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { isProviderNotReadyError } from '../common/types';
+import { buildFetchErrorAttribution, fetchErrorPayload } from '../utils/errorHandling';
 import { createSyncBlockNode, getSourceProductFromResourceIdSafe } from '../utils/utils';
 /**
  * Handles debounced batch-fetching of sync block data via `raf-schd`.
@@ -25,6 +27,17 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
       if (_this.pendingFetchRequests.size === 0) {
         return;
       }
+
+      // EDITOR-7860: not ready — skip and leave resourceIds queued for the
+      // next batch once the provider resolves. Gate-off is unchanged (the
+      // readiness check is nested under the gate so it is not consulted when
+      // the gate is off, and `fg()` stays a standalone condition so gate
+      // exposure is still tracked — satisfies @atlaskit/platform/no-preconditioning).
+      if (fg('platform_editor_blocks_patch_3')) {
+        if (_this.deps.isProviderReady && !_this.deps.isProviderReady()) {
+          return;
+        }
+      }
       var resourceIds = Array.from(_this.pendingFetchRequests);
       var syncBlockNodes = resourceIds.map(function (resId) {
         var subscriptions = _this.deps.getSubscriptions().get(resId) || {};
@@ -38,12 +51,27 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
         return _this.inFlightFetches.add(resId);
       });
       _this.deps.fetchSyncBlocksData(syncBlockNodes).catch(function (error) {
+        // EDITOR-7860: benign not-ready throw — re-queue for retry and emit
+        // nothing (no analytics, no exception-tracker noise). Checked before
+        // `logException` so the benign case stays silent. Re-schedule so the
+        // re-queued IDs are retried on the next frame even if no further
+        // `queueFetch()` arrives. Gate-off behaviour is unchanged.
+        if (isProviderNotReadyError(error) && fg('platform_editor_blocks_patch_3')) {
+          resourceIds.forEach(function (resId) {
+            return _this.pendingFetchRequests.add(resId);
+          });
+          if (!_this.isDestroyed) {
+            _this.scheduledBatchFetch();
+          }
+          return;
+        }
         logException(error, {
           location: 'editor-synced-block-provider/syncBlockBatchFetcher/batchedFetchSyncBlocks'
         });
+        var attribution = buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), error.message);
         resourceIds.forEach(function (resId) {
           var _this$deps$getFireAna;
-          (_this$deps$getFireAna = _this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(error.message, resId, getSourceProductFromResourceIdSafe(resId)));
+          (_this$deps$getFireAna = _this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(error.message, resId, getSourceProductFromResourceIdSafe(resId), attribution));
         });
       }).finally(function () {
         // If the fetcher was destroyed while the request was in flight,