@adobe/spacecat-shared-tokowaka-client 1.17.3 → 1.18.0

package/src/utils/metaconfig-utils.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/**
+ * Removes a single pattern from the metaconfig's prerender allowList in-place.
+ * Deletes the prerender key entirely when the resulting list would be empty.
+ * @param {Object} metaconfig - Metaconfig object (mutated in place)
+ * @param {string} pattern - Pattern to remove
+ * @returns {boolean} True if the allowList was changed
+ */
+export function removePatternFromMetaconfig(metaconfig, pattern) {
+  const existing = metaconfig.prerender?.allowList ?? [];
+  const updated = existing.filter((p) => p !== pattern);
+  if (updated.length === existing.length) {
+    return false;
+  }
+  if (updated.length === 0) {
+    // eslint-disable-next-line no-param-reassign
+    delete metaconfig.prerender;
+  } else {
+    // eslint-disable-next-line no-param-reassign
+    metaconfig.prerender = { allowList: updated };
+  }
+  return true;
+}
+
+/**
+ * Appends patterns to the metaconfig's prerender allowList (deduplicated).
+ * Mutates the metaconfig in place.
+ * @param {Object} metaconfig - Metaconfig object (mutated in place)
+ * @param {Array<string>} patterns - Patterns to add
+ * @returns {boolean} True if the allowList was changed
+ */
+export function addPatternsToMetaconfig(metaconfig, patterns) {
+  const existing = metaconfig.prerender?.allowList ?? [];
+  const merged = [...new Set([...existing, ...patterns])];
+  if (merged.length === existing.length) {
+    return false;
+  }
+  // eslint-disable-next-line no-param-reassign
+  metaconfig.prerender = { allowList: merged };
+  return true;
+}

package/src/utils/pattern-utils.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/**
+ * Builds a URL matcher function for a given allowedRegexPatterns entry.
+ * Patterns ending with `/*` use pathname prefix matching (e.g. `/products/*` matches `/products/`).
+ * When the pattern is `/*`, the prefix becomes '' and matches all URLs
+ * (intentional for domain-wide).
+ * Other patterns are compiled as regular expressions for backward compatibility.
+ * Returns null for patterns that cannot be compiled.
+ * @param {string} pattern
+ * @returns {((url: string) => boolean)|null}
+ */
+export function buildUrlMatcher(pattern) {
+  if (typeof pattern !== 'string' || pattern.length === 0) {
+    return null;
+  }
+  if (pattern.endsWith('/*')) {
+    const prefix = pattern.slice(0, -2); // '/products/*' → '/products', '/*' → ''
+    return (url) => {
+      try {
+        return new URL(url).pathname.startsWith(prefix);
+      } catch {
+        return false;
+      }
+    };
+  }
+  try {
+    const regex = new RegExp(pattern);
+    return (url) => regex.test(url);
+  } catch {
+    return null;
+  }
+}

package/src/utils/suggestion-utils.js

@@ -10,6 +10,30 @@
  * governing permissions and limitations under the License.
  */
 
+import { buildUrlMatcher } from './pattern-utils.js';
+
+/** Returns a shallow copy of obj with the specified keys removed. */
+export function omitKeys(obj, keys) {
+  const keySet = new Set(keys);
+  return Object.fromEntries(Object.entries(obj).filter(([k]) => !keySet.has(k)));
+}
+
+/** Matches SpaceCat API eligibility for edge deploy (non-domain-wide). */
+export function isEdgeDeployableSuggestionStatus(status) {
+  return status === 'NEW' || status === 'PENDING_VALIDATION';
+}
+
+/**
+ * Returns true if this suggestion uses pattern-based allow-list deploy (domain-wide or path-level).
+ * Detected by the presence of a non-empty allowedRegexPatterns array, or by isDomainWide: true
+ * (which may have an empty array when malformed — handled gracefully in the deploy loop).
+ */
+export function isPatternSuggestion(suggestion) {
+  const data = suggestion.getData();
+  return data?.isDomainWide === true
+    || (Array.isArray(data?.allowedRegexPatterns) && data.allowedRegexPatterns.length > 0);
+}
+
 /**
  * Groups suggestions by URL pathname
  * @param {Array} suggestions - Array of suggestion entities
@@ -67,3 +91,153 @@ export function filterEligibleSuggestions(suggestions, mapper) {
 
   return { eligible, ineligible };
 }
+
+/**
+ * Batch-saves suggestions using the optimal strategy based on count.
+ *
+ * - <= 1700: sequential chunked upsert via saveMany (chunkSize 25).
+ *   ~4s for 1700 suggestions from the DB layer, but ~11s observed end-to-end
+ *   from the API due to serialization, network, and Lambda overhead.
+ * - > 1700: parallel individual .save() via Promise.allSettled to avoid
+ *   sequential chunk bottleneck at scale.
+ *
+ * @param {Object} dataAccess - Data access layer
+ * @param {Array} suggestions - Suggestion entities to save
+ * @returns {Promise<void>}
+ */
+const PARALLEL_SAVE_THRESHOLD = 1700;
+
+export async function saveSuggestions(dataAccess, suggestions) {
+  if (suggestions.length === 0) {
+    return;
+  }
+  if (suggestions.length > PARALLEL_SAVE_THRESHOLD) {
+    const results = await Promise.allSettled(suggestions.map((s) => s.save()));
+    const failed = results.filter((r) => r.status === 'rejected');
+    if (failed.length > 0) {
+      throw new Error(
+        `${failed.length} of ${suggestions.length} suggestions failed to save: `
+        + `${failed[0].reason?.message}`,
+      );
+    }
+    return;
+  }
+  await dataAccess.Suggestion.saveMany(suggestions, { chunkSize: 25 });
+}
+
+/**
+ * Strips deployment markers from a suggestion's data and sets updatedBy.
+ * Does not save — caller is responsible for batching saves via saveSuggestions.
+ * @param {Object} suggestion - Suggestion entity
+ * @param {string} actorFallback - Fallback string when updatedBy is undefined
+ * @param {string|undefined} updatedBy - Explicit actor (overrides fallback when defined)
+ * @returns {Object} The mutated suggestion (not yet persisted)
+ */
+export function stripSuggestion(suggestion, actorFallback, updatedBy) {
+  suggestion.setData(omitKeys(suggestion.getData(), ['edgeDeployed', 'tokowakaDeployed']));
+  suggestion.setUpdatedBy(updatedBy ?? actorFallback);
+  return suggestion;
+}
+
+/**
+ * Clears coverage and deployment markers from suggestions that were covered by a pattern.
+ * Only strips the fields relevant to the rollback type so independent coverage layers
+ * are preserved. For example, rolling back domain-wide should only clear
+ * coveredByDomainWide — not coveredByPattern (which belongs to a separate path deploy).
+ * @param {Object} dataAccess - Data access layer
+ * @param {Array} covered - Covered suggestion entities
+ * @param {string} actorFallback - Fallback updatedBy string
+ * @param {string|undefined} updatedBy - Explicit actor
+ * @param {string[]} fieldsToStrip - Specific fields to remove
+ * @param {Object} log - Logger instance
+ * @returns {Promise<void>}
+ */
+// eslint-disable-next-line max-len
+export async function cleanupCoveredSuggestions(dataAccess, covered, actorFallback, updatedBy, fieldsToStrip, log) {
+  if (covered.length === 0) {
+    return;
+  }
+  covered.forEach((cs) => {
+    cs.setData(omitKeys(cs.getData(), fieldsToStrip));
+    cs.setUpdatedBy(updatedBy ?? actorFallback);
+  });
+  try {
+    await saveSuggestions(dataAccess, covered);
+  } catch (error) {
+    // eslint-disable-next-line max-len
+    log.error(`[edge-rollback-failed] Failed to clean ${covered.length} covered suggestion(s): ${error.message}`);
+  }
+}
+
+/**
+ * Classifies a batch of target suggestions into pattern-based and per-URL buckets.
+ * Pattern suggestions (domain-wide or path-level) are returned as
+ * `{ suggestion, allowedRegexPatterns }` objects; per-URL suggestions are filtered
+ * to only those with a deployable status.
+ * @param {Array} targetSuggestions
+ * @param {Object} log - Logger instance
+ * @returns {{ patternSuggestions: Array, validSuggestions: Array }}
+ */
+export function classifySuggestions(targetSuggestions, log) {
+  const patternSuggestions = [];
+  const validSuggestions = [];
+
+  targetSuggestions.forEach((suggestion) => {
+    const data = suggestion.getData();
+    if (isPatternSuggestion(suggestion)) {
+      log.info(
+        `[edge-deploy] Classified as PATTERN: ${suggestion.getId()} `
+        + `patterns=${JSON.stringify(data.allowedRegexPatterns)} `
+        + `isDomainWide=${data?.isDomainWide}`,
+      );
+      patternSuggestions.push({ suggestion, allowedRegexPatterns: data.allowedRegexPatterns });
+    } else if (isEdgeDeployableSuggestionStatus(suggestion.getStatus())) {
+      validSuggestions.push(suggestion);
+    }
+  });
+
+  return { patternSuggestions, validSuggestions };
+}
+
+/**
+ * Splits validSuggestions into those covered by an in-batch pattern and those that are not.
+ * Returns the two arrays; validSuggestions itself is not mutated.
+ * @param {Array} validSuggestions - Per-URL suggestions
+ * @param {Array} patternSuggestions - Pattern suggestions in the same batch
+ * @param {Object} log - Logger instance
+ * @returns {{ remaining: Array, skippedInBatch: Array }}
+ */
+export function filterBatchCoveredSuggestions(validSuggestions, patternSuggestions, log) {
+  if (patternSuggestions.length === 0 || validSuggestions.length === 0) {
+    return { remaining: validSuggestions, skippedInBatch: [] };
+  }
+
+  // Build matchers per pattern suggestion so we can track which type covered each URL.
+  // eslint-disable-next-line max-len
+  const matcherEntries = patternSuggestions.flatMap(({ suggestion, allowedRegexPatterns }) => {
+    const isDomainWide = suggestion.getData()?.isDomainWide === true;
+    return allowedRegexPatterns
+      .map(buildUrlMatcher)
+      .filter(Boolean)
+      .map((matcher) => ({ matcher, isDomainWide }));
+  });
+
+  if (matcherEntries.length === 0) {
+    return { remaining: validSuggestions, skippedInBatch: [] };
+  }
+
+  const remaining = [];
+  const skippedInBatch = [];
+  validSuggestions.forEach((s) => {
+    const url = s.getData()?.url;
+    const match = url && matcherEntries.find(({ matcher }) => matcher(url));
+    if (match) {
+      skippedInBatch.push({ suggestion: s, isDomainWide: match.isDomainWide });
+      log.info(`[edge-deploy] Skipping suggestion ${s.getId()} - covered by pattern`);
+    } else {
+      remaining.push(s);
+    }
+  });
+
+  return { remaining, skippedInBatch };
+}