@adobe/spacecat-shared-data-access 3.74.0 → 3.74.2

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [@adobe/spacecat-shared-data-access-v3.74.2](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v3.74.1...@adobe/spacecat-shared-data-access-v3.74.2) (2026-06-11)
+
+### Bug Fixes
+
+* reset linked issue status to NEW on FixEntity removal ([#1668](https://github.com/adobe/spacecat-shared/issues/1668)) ([46c54b8](https://github.com/adobe/spacecat-shared/commit/46c54b8829ea3b00029a4afa0cb835f3e7983dc9))
+
+## [@adobe/spacecat-shared-data-access-v3.74.1](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v3.74.0...@adobe/spacecat-shared-data-access-v3.74.1) (2026-06-09)
+
+### Bug Fixes
+
+* site-level handler overrides were ignored, org-level disable always won ([#1590](https://github.com/adobe/spacecat-shared/issues/1590)) ([cfeca81](https://github.com/adobe/spacecat-shared/commit/cfeca81266351c7523d939cb3a2f50831599b927)), closes [#updatedHandler](https://github.com/adobe/spacecat-shared/issues/updatedHandler)
+
 ## [@adobe/spacecat-shared-data-access-v3.74.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v3.73.3...@adobe/spacecat-shared-data-access-v3.74.0) (2026-06-02)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-data-access",
-  "version": "3.74.0",
+  "version": "3.74.2",
   "description": "Shared modules of the Spacecat Services - Data Access",
   "type": "module",
   "engines": {

package/src/models/configuration/configuration.model.js

@@ -174,6 +174,21 @@ class Configuration {
       .map((job) => job.type);
   }
 
+  /**
+   * Returns whether a handler is enabled for a given site.
+   *
+   * Precedence (highest to lowest):
+   *   1. disabled.sites includes siteId → false (site explicitly disabled)
+   *   2. enabled.sites includes siteId  → true  (site explicitly enabled; overrides org-level)
+   *   3. disabled.orgs includes orgId   → false (org disabled, no site-level override present)
+   *   4. enabledByDefault               → true
+   *   5. enabled.orgs includes orgId    → true
+   *   6. otherwise                      → false
+   *
+   * Note: disabled.sites and enabled.sites are assumed disjoint; disabled.sites wins if violated
+   * (see #updatedHandler which keeps these lists disjoint on every write).
+   * isHandlerEnabledForOrg uses a different (simpler) precedence — see its JSDoc.
+   */
   isHandlerEnabledForSite(type, site) {
     const handler = this.getHandlers()?.[type];
     if (!handler) {
@@ -183,26 +198,53 @@ class Configuration {
     const siteId = site.getId();
     const orgId = site.getOrganizationId();
 
-    if (handler.disabled) {
-      const sites = handler.disabled.sites || [];
-      const orgs = handler.disabled.orgs || [];
-      if (sites.includes(siteId) || orgs.includes(orgId)) {
-        return false;
+    const disabledSites = handler.disabled?.sites || [];
+    const enabledSites = handler.enabled?.sites || [];
+    const disabledOrgs = handler.disabled?.orgs || [];
+    const enabledOrgs = handler.enabled?.orgs || [];
+
+    // Site-level takes priority over org-level: an explicit site enable/disable
+    // overrides the org-level setting, allowing a single site to be upgraded to
+    // a paid profile even if the org is in disabled.orgs.
+    if (disabledSites.includes(siteId)) {
+      return false;
+    }
+    if (enabledSites.includes(siteId)) {
+      if (disabledOrgs.includes(orgId)) {
+        // TODO(SITES-44467): demote to debug after 30-day canary window
+        this.log.info('[isHandlerEnabledForSite] site-override: site in enabled.sites overrides org in disabled.orgs', { type, siteId, orgId });
       }
+      return true;
     }
 
+    if (disabledOrgs.includes(orgId)) {
+      return false;
+    }
     if (handler.enabledByDefault) {
       return true;
     }
-    if (handler.enabled) {
-      const sites = handler.enabled.sites || [];
-      const orgs = handler.enabled.orgs || [];
-      return sites.includes(siteId) || orgs.includes(orgId);
-    }
-
-    return false;
+    return enabledOrgs.includes(orgId);
   }
 
+  /**
+   * Returns whether a handler is enabled for a given org.
+   *
+   * Precedence (highest to lowest):
+   *   1. disabled.orgs includes orgId → false
+   *   2. enabledByDefault             → true
+   *   3. enabled.orgs includes orgId  → true
+   *   4. otherwise                    → false
+   *
+   * Note: unlike isHandlerEnabledForSite, there is no site-level override here.
+   * An org in disabled.orgs is always disabled regardless of site-level entries.
+   *
+   * Cross-system consequence: callers that fan out on org policy (e.g. org-scoped
+   * digests or batch jobs keyed on orgId) use this method as their gate. A site in
+   * enabled.sites whose org is in disabled.orgs will pass site-level evaluation
+   * (true via isHandlerEnabledForSite) but will NOT pass org-level evaluation
+   * (false here). This asymmetry is intentional: org-scoped fan-out follows org
+   * policy; site-level overrides do not propagate to org-scoped callers.
+   */
   isHandlerEnabledForOrg(type, org) {
     const handler = this.getHandlers()?.[type];
     if (!handler) {
@@ -243,20 +285,21 @@ class Configuration {
     }
 
     if (enabled) {
-      if (handler.enabledByDefault) {
-        handler.disabled[entityKey] = handler.disabled[entityKey]
-          /* c8 ignore next */
-          .filter((id) => id !== entityId) || [];
-      } else {
-        handler.enabled[entityKey] = Array
-          .from(new Set([...(handler.enabled[entityKey] || []), entityId]));
-      }
+      // Always remove from disabled first (handles re-enabling a previously disabled entry).
+      handler.disabled[entityKey] = (handler.disabled[entityKey] || [])
+        .filter((id) => id !== entityId);
+      // Always add to enabled so isHandlerEnabledForSite can find the site in enabled.sites
+      // and return true even when the org is in disabled.orgs (site-level override).
+      handler.enabled[entityKey] = Array
+        .from(new Set([...(handler.enabled[entityKey] || []), entityId]));
     } else if (handler.enabledByDefault) {
       handler.disabled[entityKey] = Array
         .from(new Set([...(handler.disabled[entityKey] || []), entityId]));
+      handler.enabled[entityKey] = (handler.enabled[entityKey] || [])
+        .filter((id) => id !== entityId);
     } else {
-      /* c8 ignore next */
-      handler.enabled[entityKey] = handler.enabled[entityKey].filter((id) => id !== entityId) || [];
+      handler.enabled[entityKey] = (handler.enabled[entityKey] || [])
+        .filter((id) => id !== entityId);
     }
 
     handlers[type] = handler;

package/src/models/fix-entity/fix-entity.model.js

@@ -44,6 +44,50 @@ class FixEntity extends BaseModel {
     return fixEntityCollection
       .getSuggestionsByFixEntityId(this.getId());
   }
+
+  /**
+   * Removes this FixEntity. When the fix is bound to a specific issue (granular CWV
+   * model — `changeDetails.issueId` is set), also rewinds every linked Suggestion so
+   * the issue is reopenable: clears `data.issues[issueId].fixEntityId` and resets
+   * that issue's status to NEW. The fix row and its junction rows are deleted by the
+   * inherited remove flow.
+   *
+   * Skipped when the fix has no issueId (legacy / non-CWV fixes) — same behavior as
+   * before. Also skipped when this method is reached as a dependent cascade (parent
+   * removal goes through `_remove()` directly), since the parent teardown moots the
+   * per-issue rewind.
+   */
+  async remove() {
+    const issueId = this.record?.changeDetails?.issueId;
+    if (issueId) {
+      await this.#resetLinkedIssues(issueId);
+    }
+    return super.remove();
+  }
+
+  async #resetLinkedIssues(issueId) {
+    const suggestions = await this.getSuggestions();
+
+    await Promise.all(suggestions.map(async (suggestion) => {
+      const data = suggestion.getData();
+      if (!data || !Array.isArray(data.issues)) {
+        return;
+      }
+      let mutated = false;
+      const nextIssues = data.issues.map((issue) => {
+        if (issue && issue.id === issueId) {
+          mutated = true;
+          return { ...issue, status: 'NEW', fixEntityId: null };
+        }
+        return issue;
+      });
+      if (!mutated) {
+        return;
+      }
+      suggestion.setData({ ...data, issues: nextIssues });
+      await suggestion.save();
+    }));
+  }
 }
 
 export default FixEntity;