@adobe/spacecat-shared-tokowaka-client 1.12.1 → 1.12.3

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [@adobe/spacecat-shared-tokowaka-client-v1.12.3](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.12.2...@adobe/spacecat-shared-tokowaka-client-v1.12.3) (2026-03-28)
+
+### Bug Fixes
+
+* **deps:** update external fixes ([#1477](https://github.com/adobe/spacecat-shared/issues/1477)) ([67bdd1a](https://github.com/adobe/spacecat-shared/commit/67bdd1a2c497bed088bc1e54ae22e60c171308d1))
+
+## [@adobe/spacecat-shared-tokowaka-client-v1.12.2](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.12.1...@adobe/spacecat-shared-tokowaka-client-v1.12.2) (2026-03-25)
+
+### Bug Fixes
+
+* optimize preview api ([#1412](https://github.com/adobe/spacecat-shared/issues/1412)) ([3efb9de](https://github.com/adobe/spacecat-shared/commit/3efb9deb1ee6ad962b5288ef124f96fbfbb6e4ae))
+
 ## [@adobe/spacecat-shared-tokowaka-client-v1.12.1](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.12.0...@adobe/spacecat-shared-tokowaka-client-v1.12.1) (2026-03-21)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-tokowaka-client",
-  "version": "1.12.1",
+  "version": "1.12.3",
   "description": "Tokowaka Client for SpaceCat - Edge optimization config management",
   "type": "module",
   "engines": {
@@ -35,8 +35,8 @@
   },
   "dependencies": {
     "@adobe/spacecat-shared-utils": "1.81.1",
-    "@aws-sdk/client-cloudfront": "3.1014.0",
-    "@aws-sdk/client-s3": "3.1014.0",
+    "@aws-sdk/client-cloudfront": "3.1019.0",
+    "@aws-sdk/client-s3": "3.1019.0",
     "hast-util-from-html": "2.0.3",
     "mdast-util-from-markdown": "2.0.3",
     "mdast-util-to-hast": "13.2.1",

package/src/index.js

@@ -991,6 +991,19 @@ class TokowakaClient {
 
     const forwardedHost = calculateForwardedHost(previewUrl, this.log);
 
+    const originalHtmlPromise = fetchHtmlWithWarmup(
+      previewUrl,
+      apiKey,
+      forwardedHost,
+      edgeUrl,
+      this.log,
+      false,
+      options,
+    ).catch((err) => {
+      this.log.error(`Failed to fetch original HTML: ${err.message}`);
+      return null;
+    });
+
     // Generate configuration with eligible preview suggestions
     this.log.info(`Generating preview Tokowaka config for opportunity ${opportunity.getId()}`);
     const newConfig = this.generateConfig(previewUrl, opportunity, eligibleSuggestions);
@@ -1047,38 +1060,33 @@ class TokowakaClient {
     let cdnInvalidationResults = null;
 
     try {
-      const fetchAndInvalidateStartTime = Date.now();
-      // Fetch original HTML and invalidate CDN cache in parallel to save time
-      [originalHtml, cdnInvalidationResults] = await Promise.all([
+      // Invalidate CDN so edge serves fresh content for optimized fetch
+      cdnInvalidationResults = await this.invalidateCdnCache({
+        urls: [previewUrl],
+        isPreview: true,
+      });
+
+      // Await original HTML (started earlier) and fetch optimized HTML in parallel
+      const fetchStartTime = Date.now();
+      [originalHtml, optimizedHtml] = await Promise.all([
+        originalHtmlPromise,
         fetchHtmlWithWarmup(
           previewUrl,
           apiKey,
           forwardedHost,
           edgeUrl,
           this.log,
-          false,
+          true,
           options,
         ),
-        this.invalidateCdnCache({
-          urls: [previewUrl],
-          isPreview: true,
-        }),
       ]);
-      this.log.info('Successfully fetched original HTML and invalidated CDN cache'
-        + ` in ${Date.now() - fetchAndInvalidateStartTime}ms`);
-
-      // Step 2: Fetch optimized HTML after CDN invalidation and original fetch complete
-      this.log.info('Fetching optimized HTML...');
-      optimizedHtml = await fetchHtmlWithWarmup(
-        previewUrl,
-        apiKey,
-        forwardedHost,
-        edgeUrl,
-        this.log,
-        true,
-        options,
-      );
-      this.log.info('Successfully fetched optimized HTML');
+      /* c8 ignore start */
+      if (!originalHtml || !optimizedHtml) {
+        throw this.#createError('Failed to fetch original or optimized HTML', HTTP_INTERNAL_SERVER_ERROR);
+      }
+      /* c8 ignore stop */
+      this.log.info('Successfully fetched original and optimized HTML'
+        + ` in ${Date.now() - fetchStartTime}ms`);
     } catch (error) {
       this.log.error(`Failed to fetch HTML for preview: ${error.message}`);
       throw this.#createError(

package/src/utils/custom-html-utils.js

@@ -12,6 +12,9 @@
 
 import { hasText } from '@adobe/spacecat-shared-utils';
 
+const ORIGINAL_FETCH_TYPE = 'original';
+const OPTIMIZED_FETCH_TYPE = 'optimized';
+
 /**
  * Helper function to wait for a specified duration
  * @param {number} ms - Milliseconds to wait
@@ -39,10 +42,11 @@ async function fetchWithTimeout(url, options = {}, timeout = 3000) {
 
 /**
  * Makes an HTTP request with retry logic for both original and optimized HTML.
- * Header validation logic (same for both):
- * - No proxy AND no cache header: Return response immediately (success)
- * - Proxy header present BUT no cache header: Retry until cache header found
+ * Header validation logic:
  * - Cache header present (regardless of proxy): Return response (success)
+ * - No proxy AND no cache header: If fetching optimized, retry; else success
+ * - Proxy header present BUT no cache header: Retry until cache header found
+ * - 301: Retry with the same URL (same as other non-ok responses)
  * @param {string} url - URL to fetch
  * @param {Object} options - Fetch options
  * @param {number} maxRetries - Maximum number of retries
@@ -63,7 +67,7 @@ async function fetchWithRetry(url, options, maxRetries, retryDelayMs, log, fetch
       const requestId = response?.headers?.get('x-edgeoptimize-request-id');
       log.info(`[${fetchType}] Response status (attempt ${attempt}): ${response.status} ${response.statusText}, x-edgeoptimize-request-id: ${requestId || 'none'}`);
 
-      if (!response.ok) {
+      if (!response.ok && response.status !== 301) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
 
@@ -79,15 +83,15 @@ async function fetchWithRetry(url, options, maxRetries, retryDelayMs, log, fetch
         return response;
       }
 
-      // Case 2: No cache header AND no proxy header -> Success (return immediately)
+      // No cache header AND no proxy header
       if (!proxyHeader) {
-        log.info(`[${fetchType}] No edge optimize headers found, proceeding as successful flow`);
-        return response;
+        if (fetchType === ORIGINAL_FETCH_TYPE && response.status !== 301) {
+          log.info(`[${fetchType}] No edge optimize headers found, proceeding as successful flow`);
+          return response;
+        }
+        log.info(`[${fetchType}] No proxy/cache header found`);
       }
 
-      // Case 3: Proxy header present BUT no cache header -> Retry until cache found
-      log.info(`[${fetchType}] Proxy header present without cache header, will retry...`);
-
       // If we haven't exhausted retries, continue
       if (attempt < maxRetries + 1) {
         log.debug(`[${fetchType}] Waiting ${retryDelayMs}ms before retry...`);
@@ -127,7 +131,7 @@ async function fetchWithRetry(url, options, maxRetries, retryDelayMs, log, fetch
  * @param {Object} log - Logger instance
  * @param {Object} options - Additional options
  * @param {number} options.warmupDelayMs - Delay after warmup call (default: 1000ms)
- * @param {number} options.maxRetries - Maximum number of retries for actual call (default: 3)
+ * @param {number} options.maxRetries - Maximum number of retries for actual call (default: 5)
  * @param {number} options.retryDelayMs - Delay between retries (default: 1000ms)
  * @returns {Promise<string>} - HTML content
  * @throws {Error} - If validation fails or fetch fails after retries or timeout
@@ -157,11 +161,11 @@ export async function fetchHtmlWithWarmup(
   // Default options
   const {
     warmupDelayMs = isOptimized ? 750 : 0, // milliseconds
-    maxRetries = 3,
-    retryDelayMs = 1000,
+    maxRetries = 8,
+    retryDelayMs = 1500,
   } = options;
 
-  const fetchType = isOptimized ? 'optimized' : 'original';
+  const fetchType = isOptimized ? OPTIMIZED_FETCH_TYPE : ORIGINAL_FETCH_TYPE;
 
   // Parse the URL to extract path and construct full URL
   const urlObj = new URL(url);

package/test/index.test.js

@@ -3292,6 +3292,35 @@ describe('TokowakaClient', () => {
       }
     });
 
+    it('should throw when original HTML fetch returns null (e.g. early fetch failed and resolved null)', async () => {
+      const okResponse = {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: { get: (name) => (name === 'x-edgeoptimize-cache' ? 'HIT' : null) },
+        text: async () => '<html><body>Test HTML</body></html>',
+      };
+      fetchStub.resetBehavior();
+      fetchStub.onCall(0).resolves(okResponse);
+      fetchStub.onCall(1).resolves(okResponse);
+      fetchStub.onCall(2).resolves(okResponse);
+      fetchStub.onCall(3).rejects(new Error('Original actual fetch failed'));
+
+      try {
+        await client.previewSuggestions(
+          mockSite,
+          mockOpportunity,
+          mockSuggestions,
+          { warmupDelayMs: 0, maxRetries: 0, retryDelayMs: 0 },
+        );
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.satisfy((msg) => msg.includes('Failed to fetch original or optimized HTML')
+        || msg.includes('Preview failed'));
+        expect(error.status).to.equal(500);
+      }
+    });
+
     it('should merge with existing deployed patches for the same URL', async () => {
       // Setup existing config with deployed patches
       const existingConfig = {

package/test/utils/html-utils.test.js

@@ -197,6 +197,7 @@ describe('HTML Utils', () => {
     });
 
     it('should use default warmup delay of 750ms for optimized HTML', async () => {
+      fetchStub.reset();
       fetchStub.resolves({
         ok: true,
         status: 200,
@@ -221,10 +222,10 @@ describe('HTML Utils', () => {
       const elapsed = Date.now() - startTime;
       expect(html).to.equal('<html>Optimized HTML</html>');
       expect(fetchStub.callCount).to.equal(2); // warmup + actual
-      expect(elapsed).to.be.at.least(750); // Should not have waited (0ms warmup)
+      expect(elapsed).to.be.at.least(750); // Default warmup delay for optimized is 750ms
     });
 
-    it('should return immediately for optimized HTML when no headers present', async () => {
+    it('should retry and throw for optimized HTML when no proxy or cache headers present', async () => {
       // Warmup succeeds
       fetchStub.onCall(0).resolves({
         ok: true,
@@ -235,30 +236,35 @@ describe('HTML Utils', () => {
         },
         text: async () => 'warmup',
       });
-      // First actual call - no headers, should succeed
-      fetchStub.onCall(1).resolves({
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {
-          get: () => null,
-        },
-        text: async () => '<html>No headers</html>',
-      });
-
-      const html = await fetchHtmlWithWarmup(
-        'https://example.com/page',
-        'api-key',
-        'host',
-        'https://edge.example.com',
-        log,
-        true, // isOptimized
-        { warmupDelayMs: 0, maxRetries: 3, retryDelayMs: 0 },
-      );
+      for (let i = 1; i <= 4; i += 1) {
+        fetchStub.onCall(i).resolves({
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          headers: {
+            get: () => null,
+          },
+          text: async () => '<html>No headers</html>',
+        });
+      }
 
-      expect(html).to.equal('<html>No headers</html>');
-      // Should succeed immediately (warmup + 1 attempt)
-      expect(fetchStub.callCount).to.equal(2);
+      try {
+        await fetchHtmlWithWarmup(
+          'https://example.com/page',
+          'api-key',
+          'host',
+          'https://edge.example.com',
+          log,
+          true, // isOptimized
+          { warmupDelayMs: 0, maxRetries: 3, retryDelayMs: 0 },
+        );
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Failed to fetch optimized HTML');
+        expect(error.message).to.include('Cache header (x-edgeoptimize-cache) not found after 3 retries');
+      }
+      // Warmup + 4 actual attempts (initial + 3 retries)
+      expect(fetchStub.callCount).to.equal(5);
     });
 
     it('should throw error for optimized HTML when proxy present but cache not found after retries', async () => {
@@ -406,6 +412,50 @@ describe('HTML Utils', () => {
       }
     });
 
+    it('should retry with same URL on 301 response', async () => {
+      const sameUrl = 'https://edge.example.com/page';
+      // Warmup succeeds
+      fetchStub.onCall(0).resolves({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: { get: () => null },
+        text: async () => 'warmup',
+      });
+      // First actual call returns 301
+      fetchStub.onCall(1).resolves({
+        ok: false,
+        status: 301,
+        statusText: 'Moved Permanently',
+        headers: { get: () => null },
+      });
+      // Second call (same URL) succeeds with cache header
+      fetchStub.onCall(2).resolves({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {
+          get: (name) => (name === 'x-edgeoptimize-cache' ? 'HIT' : null),
+        },
+        text: async () => '<html>OK</html>',
+      });
+
+      const html = await fetchHtmlWithWarmup(
+        'https://example.com/page',
+        'api-key',
+        'host',
+        'https://edge.example.com',
+        log,
+        false,
+        { warmupDelayMs: 0, maxRetries: 2, retryDelayMs: 0 },
+      );
+
+      expect(html).to.equal('<html>OK</html>');
+      expect(fetchStub.callCount).to.equal(3); // warmup + 301 + retry same URL
+      expect(fetchStub.getCall(1).args[0]).to.equal(sameUrl);
+      expect(fetchStub.getCall(2).args[0]).to.equal(sameUrl);
+    });
+
     it('should retry and eventually throw error after max retries', async () => {
       // Warmup succeeds
       fetchStub.onCall(0).resolves({