@adobe/spacecat-shared-tokowaka-client 1.21.0 → 1.21.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [@adobe/spacecat-shared-tokowaka-client-v1.21.1](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.21.0...@adobe/spacecat-shared-tokowaka-client-v1.21.1) (2026-07-15)
+
+### Bug Fixes
+
+* utility for marking suggestions as covered ([#1810](https://github.com/adobe/spacecat-shared/issues/1810)) ([2709d47](https://github.com/adobe/spacecat-shared/commit/2709d4741bfe2968dfb481ceedf3e283525f5e71))
+
 ## [@adobe/spacecat-shared-tokowaka-client-v1.21.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.20.0...@adobe/spacecat-shared-tokowaka-client-v1.21.0) (2026-07-14)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-tokowaka-client",
-  "version": "1.21.0",
+  "version": "1.21.1",
   "description": "Tokowaka Client for SpaceCat - Edge optimization config management",
   "type": "module",
   "engines": {

package/src/index.js

@@ -27,7 +27,6 @@ import {
 } from './utils/s3-utils.js';
 import {
   omitKeys,
-  isEdgeDeployableSuggestionStatus,
   isPatternSuggestion,
   groupSuggestionsByUrlPath,
   filterEligibleSuggestions,
@@ -36,8 +35,8 @@ import {
   cleanupCoveredSuggestions,
   classifySuggestions,
   filterBatchCoveredSuggestions,
+  findCoveredSuggestions,
 } from './utils/suggestion-utils.js';
-import { buildUrlMatcher } from './utils/pattern-utils.js';
 import { getEffectiveBaseURL } from './utils/site-utils.js';
 import { removePatternFromMetaconfig, addPatternsToMetaconfig } from './utils/metaconfig-utils.js';
 import { fetchHtmlWithWarmup, calculateForwardedHost } from './utils/custom-html-utils.js';
@@ -1559,41 +1558,13 @@ class TokowakaClient {
     suggestion.setUpdatedBy(updatedBy);
     // suggestion.save() is deferred — caller batches saves via saveSuggestions.
 
-    // Mark per-URL suggestions covered by this pattern.
-    const matchers = allowedRegexPatterns.flatMap((p) => {
-      const m = buildUrlMatcher(p);
-      if (!m) {
-        // eslint-disable-next-line max-len
-        this.log.warn(`[edge-deploy] Pattern '${p}' for suggestion ${suggestion.getId()} is invalid, skipping`);
-      }
-      return m ? [m] : [];
-    });
-
-    if (matchers.length === 0) {
-      return;
-    }
-
-    const covered = allSuggestions.filter((s) => {
-      if (s.getId() === suggestion.getId()) {
-        return false;
-      }
-      if (skippedInBatchIds.has(s.getId())) {
-        return false;
-      }
-      if (!isEdgeDeployableSuggestionStatus(s.getStatus())) {
-        return false;
-      }
-      if (s.getData()?.edgeDeployed) {
-        return false;
-      }
-      // Path-level pattern suggestions (not domain-wide) are fully covered by a
-      // domain-wide deployment. Other pattern suggestions (including other DW ones) are not.
-      if (isPatternSuggestion(s)) {
-        return coverageField === 'coveredByDomainWide' && !s.getData()?.isDomainWide;
-      }
-      const url = s.getData()?.url;
-      return url && matchers.some((match) => match(url));
-    });
+    const covered = findCoveredSuggestions(
+      suggestion,
+      allowedRegexPatterns,
+      allSuggestions,
+      skippedInBatchIds,
+      this.log,
+    );
 
     // eslint-disable-next-line max-len
     this.log.info(`[edge-deploy] Pattern ${suggestion.getId()}: found ${covered.length} coverable per-URL suggestions (field=${coverageField})`);
@@ -1759,6 +1730,64 @@ class TokowakaClient {
     return { succeededSuggestions, failedSuggestions, coveredSuggestions };
   }
 
+  /**
+   * Finds and marks the suggestions that fall within a pattern suggestion's
+   * scope (domain-wide or segment/path) as covered and saves them.
+   *
+   * @param {Object} patternSuggestion - The domain-wide / segment pattern suggestion
+   * @param {Array} allSuggestions - Full opportunity suggestion list to search for matches
+   * @param {string} siteId - Site ID
+   * @param {string} [updatedBy]
+   * @returns {Promise<Array>} the marked suggestions
+   */
+  async markPatternCoveredSuggestions(
+    patternSuggestion,
+    allSuggestions,
+    siteId,
+    updatedBy = 'edge-deploy',
+  ) {
+    const allowedRegexPatterns = patternSuggestion.getData()?.allowedRegexPatterns;
+    if (!Array.isArray(allowedRegexPatterns) || allowedRegexPatterns.length === 0) {
+      this.log.warn(`[edge-deploy] Pattern suggestion ${patternSuggestion.getId()} has `
+      + 'no allowedRegexPatterns, skipping cover-marking');
+      return [];
+    }
+    const covered = findCoveredSuggestions(
+      patternSuggestion,
+      allowedRegexPatterns,
+      allSuggestions,
+      new Set(),
+      this.log,
+    );
+    if (covered.length === 0) {
+      return [];
+    }
+    const coverageField = patternSuggestion.getData()?.isDomainWide
+      ? 'coveredByDomainWide' : 'coveredByPattern';
+    covered.forEach((s) => {
+      s.setData({ ...s.getData(), [coverageField]: patternSuggestion.getId() });
+      s.setUpdatedBy(updatedBy);
+    });
+    try {
+      await saveSuggestions(this.dataAccess, covered, {
+        sqs: this.sqs,
+        queueUrl: this.importWorkerQueueUrl,
+        siteId,
+        set: { [coverageField]: patternSuggestion.getId() },
+        updatedBy,
+        log: this.log,
+      });
+      this.log.info(`[edge-deploy] Marked ${covered.length} suggestions as ${coverageField}=${patternSuggestion.getId()}`);
+      return covered;
+    } catch (saveError) {
+      this.log.warn(
+        '[edge-deploy] Failed to mark covered suggestions for pattern suggestion '
+        + `${patternSuggestion.getId()}: ${saveError.message}`,
+      );
+      return [];
+    }
+  }
+
   /**
    * Strips the `applyStale` flag from patches in S3 for the given per-URL suggestions.
    * Called when an experiment completes so edge reverts to normal (non-stale) behaviour.

package/src/utils/suggestion-utils.js

@@ -284,3 +284,58 @@ export function filterBatchCoveredSuggestions(validSuggestions, patternSuggestio
 
   return { remaining, skippedInBatch };
 }
+
+/**
+ * Finds the suggestions in `allSuggestions` that are covered by a pattern suggestion's
+ * allowedRegexPatterns
+ *
+ * @param {Object} patternSuggestion - The domain-wide / segment pattern suggestion
+ * @param {Array<string>} allowedRegexPatterns
+ * @param {Array} allSuggestions - Full opportunity suggestion list to search
+ * @param {Set<string>} [excludeIds] - Suggestion IDs to skip (e.g. already handled in-batch)
+ * @param {Object} log - Logger instance
+ * @returns {Array} Suggestions covered by the pattern
+ */
+export function findCoveredSuggestions(
+  patternSuggestion,
+  allowedRegexPatterns,
+  allSuggestions,
+  excludeIds,
+  log,
+) {
+  const isDomainWide = patternSuggestion.getData()?.isDomainWide === true;
+  const matchers = allowedRegexPatterns.flatMap((p) => {
+    const m = buildUrlMatcher(p);
+    if (!m) {
+      // eslint-disable-next-line max-len
+      log.warn(`[edge-deploy] Pattern '${p}' for suggestion ${patternSuggestion.getId()} is invalid, skipping`);
+    }
+    return m ? [m] : [];
+  });
+
+  if (matchers.length === 0) {
+    return [];
+  }
+
+  return allSuggestions.filter((s) => {
+    if (s.getId() === patternSuggestion.getId()) {
+      return false;
+    }
+    if (excludeIds?.has(s.getId())) {
+      return false;
+    }
+    if (!isEdgeDeployableSuggestionStatus(s.getStatus())) {
+      return false;
+    }
+    if (s.getData()?.edgeDeployed) {
+      return false;
+    }
+    // Path-level pattern suggestions (not domain-wide) are fully covered by a
+    // domain-wide deployment. Other pattern suggestions (including other DW ones) are not.
+    if (isPatternSuggestion(s)) {
+      return isDomainWide && !s.getData()?.isDomainWide;
+    }
+    const url = s.getData()?.url;
+    return url && matchers.some((match) => match(url));
+  });
+}

package/test/index.test.js

@@ -147,6 +147,98 @@ describe('TokowakaClient', () => {
     });
   });
 
+  describe('markPatternCoveredSuggestions', () => {
+    const mkPattern = (isDomainWide) => ({
+      getId: () => (isDomainWide ? 'dw-1' : 'path-1'),
+      getData: () => (isDomainWide
+        ? { isDomainWide: true, allowedRegexPatterns: ['/*'] }
+        : { allowedRegexPatterns: ['/foo/*'] }),
+    });
+    const mkCovered = (id, url = `https://example.com/foo/${id}`) => ({
+      getId: () => id,
+      getStatus: () => 'NEW',
+      getData: () => ({ url }),
+      setData: sinon.stub(),
+      setUpdatedBy: sinon.stub(),
+      save: sinon.stub().resolves(),
+    });
+
+    it('marks all matching suggestions in the opportunity with coveredByDomainWide', async () => {
+      const covered = [mkCovered('a'), mkCovered('b')];
+
+      const result = await client.markPatternCoveredSuggestions(
+        mkPattern(true),
+        covered,
+        'site-1',
+        'tester',
+      );
+
+      expect(result).to.deep.equal(covered);
+      covered.forEach((s) => {
+        expect(s.setData.calledWithMatch({ coveredByDomainWide: 'dw-1' })).to.be.true;
+        expect(s.setUpdatedBy.calledOnceWith('tester')).to.be.true;
+      });
+      expect(client.dataAccess.Suggestion.saveMany.calledOnceWith(covered)).to.be.true;
+    });
+
+    it('marks only URLs matching the segment/path pattern with coveredByPattern', async () => {
+      const matching = mkCovered('a', 'https://example.com/foo/a');
+      const nonMatching = mkCovered('b', 'https://example.com/bar/b');
+
+      const result = await client.markPatternCoveredSuggestions(
+        mkPattern(false),
+        [matching, nonMatching],
+        'site-1',
+      );
+
+      expect(result).to.deep.equal([matching]);
+      expect(matching.setData.calledWithMatch({ coveredByPattern: 'path-1' })).to.be.true;
+      expect(matching.setUpdatedBy.calledOnceWith('edge-deploy')).to.be.true;
+      expect(nonMatching.setData.called).to.be.false;
+    });
+
+    it('is a no-op when the pattern suggestion has no allowedRegexPatterns', async () => {
+      const noPattern = { getId: () => 'dw-1', getData: () => ({ isDomainWide: true }) };
+
+      expect(await client.markPatternCoveredSuggestions(noPattern, [mkCovered('a')], 'site-1'))
+        .to.deep.equal([]);
+      expect(client.dataAccess.Suggestion.saveMany.called).to.be.false;
+    });
+
+    it('is a no-op when nothing in allSuggestions matches', async () => {
+      const result = await client.markPatternCoveredSuggestions(mkPattern(true), [], 'site-1');
+
+      expect(result).to.deep.equal([]);
+      expect(client.dataAccess.Suggestion.saveMany.called).to.be.false;
+    });
+
+    it('enqueues a bulk-update job with the passed-in siteId when covered count is large', async () => {
+      const covered = Array.from({ length: 1701 }, (_, i) => mkCovered(`c${i}`));
+      client.sqs = { sendMessage: sinon.stub().resolves() };
+      client.importWorkerQueueUrl = 'https://sqs.test/import-worker-queue';
+
+      await client.markPatternCoveredSuggestions(mkPattern(true), covered, 'site-1', 'tester');
+
+      expect(client.sqs.sendMessage).to.have.been.calledOnce;
+      const [queueUrl, payload] = client.sqs.sendMessage.firstCall.args;
+      expect(queueUrl).to.equal('https://sqs.test/import-worker-queue');
+      expect(payload).to.include({ type: 'suggestion-bulk-update', siteId: 'site-1' });
+      expect(payload.set).to.deep.equal({ coveredByDomainWide: 'dw-1' });
+      expect(payload.updatedBy).to.equal('tester');
+      expect(client.dataAccess.Suggestion.saveMany.called).to.be.false;
+    });
+
+    it('warns and returns [] instead of throwing when saveSuggestions fails', async () => {
+      client.dataAccess.Suggestion.saveMany.rejects(new Error('DB down'));
+      const covered = [mkCovered('a')];
+
+      const result = await client.markPatternCoveredSuggestions(mkPattern(true), covered, 'site-1');
+
+      expect(result).to.deep.equal([]);
+      expect(client.log.warn.calledWithMatch(/Failed to mark covered suggestions/)).to.be.true;
+    });
+  });
+
   describe('createFrom', () => {
     it('should create client from context', () => {
       const context = {