@adobe/spacecat-shared-tokowaka-client 1.5.5 → 1.5.7

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [@adobe/spacecat-shared-tokowaka-client-v1.5.7](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.5.6...@adobe/spacecat-shared-tokowaka-client-v1.5.7) (2026-01-22)
+
+
+### Bug Fixes
+
+* headings mapper for invalid headings ([#1281](https://github.com/adobe/spacecat-shared/issues/1281)) ([01734df](https://github.com/adobe/spacecat-shared/commit/01734df0de2f9d43bb6c2ee0636449c26d336ca7))
+
+# [@adobe/spacecat-shared-tokowaka-client-v1.5.6](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.5.5...@adobe/spacecat-shared-tokowaka-client-v1.5.6) (2026-01-22)
+
+
+### Bug Fixes
+
+* edge apis, ignore scrapedAt prop for lastUpdated calculation ([#1280](https://github.com/adobe/spacecat-shared/issues/1280)) ([05e4bde](https://github.com/adobe/spacecat-shared/commit/05e4bde07fc865e8d0aee71639f799798e68594d))
+* update prerender config ([#1279](https://github.com/adobe/spacecat-shared/issues/1279)) ([4502ba4](https://github.com/adobe/spacecat-shared/commit/4502ba43f6a26e5d774ce0e2e7dfc6e886ab7402))
+
 # [@adobe/spacecat-shared-tokowaka-client-v1.5.5](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.5.4...@adobe/spacecat-shared-tokowaka-client-v1.5.5) (2026-01-21)
 
 

package/package.json

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

package/src/index.js

@@ -355,20 +355,25 @@ class TokowakaClient {
       ?? existingMetaconfig.forceFail
       ?? false;
 
+    const hasPrerender = isNonEmptyObject(options.prerender)
+      || isNonEmptyObject(existingMetaconfig.prerender);
+    const prerender = options.prerender
+      ?? existingMetaconfig.prerender;
+
     const metaconfig = {
-      siteId,
-      apiKeys: existingMetaconfig.apiKeys,
+      ...existingMetaconfig,
       tokowakaEnabled: options.tokowakaEnabled ?? existingMetaconfig.tokowakaEnabled ?? true,
       enhancements: options.enhancements ?? existingMetaconfig.enhancements ?? true,
       patches: isNonEmptyObject(options.patches)
         ? options.patches
         : (existingMetaconfig.patches ?? {}),
       ...(hasForceFail && { forceFail }),
+      ...(hasPrerender && { prerender }),
     };
 
     const s3Path = await this.uploadMetaconfig(url, metaconfig);
 
-    this.log.info(`Created new Tokowaka metaconfig for ${normalizedHostName} at ${s3Path}`);
+    this.log.info(`Updated Tokowaka metaconfig for ${normalizedHostName} at ${s3Path}`);
 
     return metaconfig;
   }

package/src/mappers/base-mapper.js

@@ -88,10 +88,7 @@ export default class BaseOpportunityMapper {
    * @returns {Object} - Base patch object
    */
   createBasePatch(suggestion, opportunityId) {
-    const data = suggestion.getData();
-    const updatedAt = data?.scrapedAt
-      || data?.transformRules?.scrapedAt
-      || suggestion.getUpdatedAt();
+    const updatedAt = suggestion.getUpdatedAt();
 
     // Parse timestamp, fallback to Date.now() if invalid
     let lastUpdated = Date.now();

package/src/mappers/faq-mapper.js

@@ -111,10 +111,7 @@ export default class FaqMapper extends BaseOpportunityMapper {
     // Calculate the most recent lastUpdated from all eligible suggestions
     // The heading patch should have the same timestamp as the newest FAQ
     const maxLastUpdated = Math.max(...eligibleSuggestions.map((suggestion) => {
-      const data = suggestion.getData();
-      const updatedAt = data?.scrapedAt
-        || data?.transformRules?.scrapedAt
-        || suggestion.getUpdatedAt();
+      const updatedAt = suggestion.getUpdatedAt();
 
       if (updatedAt) {
         const parsed = new Date(updatedAt).getTime();

package/src/mappers/headings-mapper.js

@@ -67,6 +67,10 @@ export default class HeadingsMapper extends BaseOpportunityMapper {
         patch.tag = transformRules.tag;
       }
 
+      if (checkType === 'heading-order-invalid') {
+        patch.value = transformRules.value;
+        patch.valueFormat = transformRules.valueFormat;
+      }
       patches.push(patch);
     });
 

package/test/index.test.js

@@ -590,7 +590,7 @@ describe('TokowakaClient', () => {
     });
 
     it('should update metaconfig with default options', async () => {
-      const siteId = 'site-789';
+      const siteId = 'site-456';
       const url = 'https://www.example.com/page1';
 
       const result = await client.updateMetaconfig(url, siteId);
@@ -1144,6 +1144,170 @@ describe('TokowakaClient', () => {
 
       expect(result).to.have.property('forceFail', false);
     });
+
+    it('should include prerender when provided in options', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      const prerenderConfig = { allowList: ['/*'] };
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: prerenderConfig });
+
+      expect(result).to.have.property('prerender');
+      expect(result.prerender).to.deep.equal(prerenderConfig);
+    });
+
+    it('should preserve existingMetaconfig prerender when options.prerender is undefined', async () => {
+      const existingPrerenderConfig = { allowList: ['/*', '/products/*'] };
+      const configWithPrerender = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: false,
+        enhancements: false,
+        patches: {},
+        prerender: existingPrerenderConfig,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithPrerender)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('prerender');
+      expect(result.prerender).to.deep.equal(existingPrerenderConfig);
+    });
+
+    it('should use existingMetaconfig prerender when options.prerender is null', async () => {
+      const existingPrerenderConfig = { allowList: ['/*'] };
+      const configWithPrerender = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: false,
+        enhancements: false,
+        patches: {},
+        prerender: existingPrerenderConfig,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithPrerender)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: null });
+
+      expect(result).to.have.property('prerender');
+      expect(result.prerender).to.deep.equal(existingPrerenderConfig);
+    });
+
+    it('should override existingMetaconfig prerender when provided in options', async () => {
+      const existingPrerenderConfig = { allowList: ['/blog/*'] };
+      const newPrerenderConfig = { allowList: ['/*', '/products/*'] };
+      const configWithPrerender = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: false,
+        enhancements: false,
+        patches: {},
+        prerender: existingPrerenderConfig,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithPrerender)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: newPrerenderConfig });
+
+      expect(result).to.have.property('prerender');
+      expect(result.prerender).to.deep.equal(newPrerenderConfig);
+    });
+
+    it('should not include prerender when neither options nor existingMetaconfig have it', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.not.have.property('prerender');
+    });
+
+    it('should not include prerender when both options and existingMetaconfig have empty prerender', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: {} });
+
+      expect(result).to.not.have.property('prerender');
+    });
+
+    it('should include prerender from options when existingMetaconfig does not have it', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      const prerenderConfig = { allowList: ['/*'] };
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: prerenderConfig });
+
+      expect(result).to.have.property('prerender');
+      expect(result.prerender).to.deep.equal(prerenderConfig);
+    });
+
+    it('should handle prerender with multiple paths in allowList', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      const prerenderConfig = {
+        allowList: ['/*', '/products/*', '/blog/*', '/about'],
+      };
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: prerenderConfig });
+
+      expect(result).to.have.property('prerender');
+      expect(result.prerender).to.deep.equal(prerenderConfig);
+    });
+
+    it('should use options.prerender even when it is an empty object if existingMetaconfig has no prerender', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: {} });
+
+      // Empty object is not null/undefined, so it will be used by nullish coalescing
+      // But hasPrerender will be false, so it won't be included in final metaconfig
+      expect(result).to.not.have.property('prerender');
+    });
+
+    it('should handle case where existingMetaconfig.prerender is undefined and options.prerender is provided', async () => {
+      const configWithoutPrerender = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: false,
+        enhancements: false,
+        patches: {},
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithoutPrerender)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      const prerenderConfig = { allowList: ['/*'] };
+
+      const result = await client.updateMetaconfig(url, siteId, { prerender: prerenderConfig });
+
+      expect(result).to.have.property('prerender');
+      expect(result.prerender).to.deep.equal(prerenderConfig);
+    });
   });
 
   describe('uploadConfig', () => {

package/test/mappers/base-mapper.test.js

@@ -68,7 +68,6 @@ describe('BaseOpportunityMapper', () => {
       const testMapper = new TestMapper(log);
       const suggestion = {
         getId: () => 'test-123',
-        getData: () => ({}),
         getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
       };
 
@@ -94,7 +93,6 @@ describe('BaseOpportunityMapper', () => {
       const testMapper = new TestMapper(log);
       const suggestion = {
         getId: () => 'test-no-date',
-        getData: () => ({}),
         getUpdatedAt: () => null, // Returns null
       };
 
@@ -109,54 +107,6 @@ describe('BaseOpportunityMapper', () => {
       expect(patch.prerenderRequired).to.be.true;
     });
 
-    it('should prioritize scrapedAt from getData()', () => {
-      class TestMapper extends BaseOpportunityMapper {
-        getOpportunityType() { return 'test'; }
-
-        requiresPrerender() { return true; }
-
-        suggestionsToPatches() { return []; }
-
-        canDeploy() { return { eligible: true }; }
-      }
-
-      const testMapper = new TestMapper(log);
-      const scrapedTime = '2025-01-20T15:30:00.000Z';
-      const suggestion = {
-        getId: () => 'test-scraped',
-        getData: () => ({ scrapedAt: scrapedTime }),
-        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
-      };
-
-      const patch = testMapper.createBasePatch(suggestion, 'opp-scraped');
-
-      expect(patch.lastUpdated).to.equal(new Date(scrapedTime).getTime());
-    });
-
-    it('should use transformRules.scrapedAt when scrapedAt is not available', () => {
-      class TestMapper extends BaseOpportunityMapper {
-        getOpportunityType() { return 'test'; }
-
-        requiresPrerender() { return true; }
-
-        suggestionsToPatches() { return []; }
-
-        canDeploy() { return { eligible: true }; }
-      }
-
-      const testMapper = new TestMapper(log);
-      const transformScrapedTime = '2025-01-18T12:00:00.000Z';
-      const suggestion = {
-        getId: () => 'test-transform',
-        getData: () => ({ transformRules: { scrapedAt: transformScrapedTime } }),
-        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
-      };
-
-      const patch = testMapper.createBasePatch(suggestion, 'opp-transform');
-
-      expect(patch.lastUpdated).to.equal(new Date(transformScrapedTime).getTime());
-    });
-
     it('should handle invalid date strings by using Date.now()', () => {
       class TestMapper extends BaseOpportunityMapper {
         getOpportunityType() { return 'test'; }
@@ -171,7 +121,6 @@ describe('BaseOpportunityMapper', () => {
       const testMapper = new TestMapper(log);
       const suggestion = {
         getId: () => 'test-invalid',
-        getData: () => ({}),
         getUpdatedAt: () => 'invalid-date-string',
       };
 
@@ -183,29 +132,6 @@ describe('BaseOpportunityMapper', () => {
       expect(patch.lastUpdated).to.be.at.least(beforeTime);
       expect(patch.lastUpdated).to.be.at.most(afterTime);
     });
-
-    it('should handle missing getData() gracefully', () => {
-      class TestMapper extends BaseOpportunityMapper {
-        getOpportunityType() { return 'test'; }
-
-        requiresPrerender() { return true; }
-
-        suggestionsToPatches() { return []; }
-
-        canDeploy() { return { eligible: true }; }
-      }
-
-      const testMapper = new TestMapper(log);
-      const suggestion = {
-        getId: () => 'test-no-data',
-        getData: () => null,
-        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
-      };
-
-      const patch = testMapper.createBasePatch(suggestion, 'opp-no-data');
-
-      expect(patch.lastUpdated).to.equal(new Date('2025-01-15T10:00:00.000Z').getTime());
-    });
   });
 
   describe('rollbackPatches', () => {

package/test/mappers/headings-mapper.test.js

@@ -98,11 +98,12 @@ describe('HeadingsMapper', () => {
       const suggestion = {
         getData: () => ({
           checkType: 'heading-order-invalid',
-          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
           transformRules: {
             action: 'replaceWith',
             selector: '.invalid-section',
             valueFormat: 'hast',
+            value: { type: 'element', tagName: 'h2', children: [] },
           },
         }),
       };
@@ -254,11 +255,12 @@ describe('HeadingsMapper', () => {
       const suggestion = {
         getData: () => ({
           checkType: 'heading-order-invalid',
-          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
           transformRules: {
             action: 'replace',
             selector: '.invalid-section',
             valueFormat: 'hast',
+            value: { type: 'element', tagName: 'h2', children: [] },
           },
         }),
       };
@@ -275,10 +277,11 @@ describe('HeadingsMapper', () => {
       const suggestion = {
         getData: () => ({
           checkType: 'heading-order-invalid',
-          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
           transformRules: {
             action: 'replaceWith',
             selector: '.invalid-section',
+            value: { type: 'element', tagName: 'h2', children: [] },
           },
         }),
       };
@@ -295,11 +298,12 @@ describe('HeadingsMapper', () => {
       const suggestion = {
         getData: () => ({
           checkType: 'heading-order-invalid',
-          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
           transformRules: {
             action: 'replaceWith',
             selector: '.invalid-section',
             valueFormat: 'text',
+            value: { type: 'element', tagName: 'h2', children: [] },
           },
         }),
       };
@@ -447,11 +451,12 @@ describe('HeadingsMapper', () => {
         getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
         getData: () => ({
           checkType: 'heading-order-invalid',
-          recommendedAction: hastValue,
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
           transformRules: {
             action: 'replaceWith',
             selector: '.content-section',
             valueFormat: 'hast',
+            value: hastValue,
           },
         }),
       };
@@ -464,6 +469,7 @@ describe('HeadingsMapper', () => {
         op: 'replaceWith',
         selector: '.content-section',
         value: hastValue,
+        valueFormat: 'hast',
         opportunityId: 'opp-101',
         suggestionId: 'sugg-101',
         prerenderRequired: true,
@@ -477,7 +483,7 @@ describe('HeadingsMapper', () => {
         getId: () => 'sugg-102',
         getData: () => ({
           checkType: 'heading-order-invalid',
-          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
         }),
       };
 
@@ -490,11 +496,12 @@ describe('HeadingsMapper', () => {
         getId: () => 'sugg-103',
         getData: () => ({
           checkType: 'heading-order-invalid',
-          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
           transformRules: {
             action: 'replace',
             selector: '.content-section',
             valueFormat: 'hast',
+            value: { type: 'element', tagName: 'h2', children: [] },
           },
         }),
       };
@@ -503,6 +510,233 @@ describe('HeadingsMapper', () => {
       expect(patches.length).to.equal(0);
     });
 
+    it('should create patch for heading-order-invalid with real-world HAST structure', () => {
+      const hastValue = {
+        type: 'root',
+        children: [
+          {
+            type: 'element',
+            tagName: 'h2',
+            children: [
+              {
+                type: 'text',
+                value: 'Complete Cover Sets',
+              },
+            ],
+            properties: {},
+          },
+        ],
+      };
+
+      const suggestion = {
+        getId: () => 'sugg-104',
+        getUpdatedAt: () => '2026-01-03T06:24:06.229Z',
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: 'Adjust heading levels to maintain proper hierarchy.',
+          transformRules: {
+            action: 'replaceWith',
+            selector: 'h4#complete-cover-sets',
+            valueFormat: 'hast',
+            value: hastValue,
+            scrapedAt: '2026-01-03T06:24:06.229Z',
+            currValue: 'Complete Cover Sets',
+          },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-104');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch).to.deep.include({
+        op: 'replaceWith',
+        selector: 'h4#complete-cover-sets',
+        value: hastValue,
+        valueFormat: 'hast',
+        opportunityId: 'opp-104',
+        suggestionId: 'sugg-104',
+        prerenderRequired: true,
+      });
+      expect(patch.lastUpdated).to.be.a('number');
+    });
+
+    it('should create patch for heading-order-invalid with complex selector', () => {
+      const hastValue = {
+        type: 'root',
+        children: [
+          {
+            type: 'element',
+            tagName: 'h3',
+            properties: { id: 'section-title' },
+            children: [{ type: 'text', value: 'Updated Section' }],
+          },
+        ],
+      };
+
+      const suggestion = {
+        getId: () => 'sugg-105',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: 'Fix heading hierarchy from h5 to h3.',
+          transformRules: {
+            action: 'replaceWith',
+            selector: 'body > main > section:nth-child(2) > h5',
+            valueFormat: 'hast',
+            value: hastValue,
+          },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-105');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch.selector).to.equal('body > main > section:nth-child(2) > h5');
+      expect(patch.value).to.deep.equal(hastValue);
+      expect(patch.valueFormat).to.equal('hast');
+    });
+
+    it('should handle multiple heading-order-invalid suggestions', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-106',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            checkType: 'heading-order-invalid',
+            recommendedAction: 'Fix heading hierarchy.',
+            transformRules: {
+              action: 'replaceWith',
+              selector: 'h4.title',
+              valueFormat: 'hast',
+              value: {
+                type: 'root',
+                children: [
+                  {
+                    type: 'element',
+                    tagName: 'h2',
+                    properties: { class: 'title' },
+                    children: [{ type: 'text', value: 'Title 1' }],
+                  },
+                ],
+              },
+            },
+          }),
+        },
+        {
+          getId: () => 'sugg-107',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            checkType: 'heading-order-invalid',
+            recommendedAction: 'Fix another heading.',
+            transformRules: {
+              action: 'replaceWith',
+              selector: 'h5.subtitle',
+              valueFormat: 'hast',
+              value: {
+                type: 'root',
+                children: [
+                  {
+                    type: 'element',
+                    tagName: 'h3',
+                    properties: { class: 'subtitle' },
+                    children: [{ type: 'text', value: 'Subtitle' }],
+                  },
+                ],
+              },
+            },
+          }),
+        },
+      ];
+
+      const patches = mapper.suggestionsToPatches('/path', suggestions, 'opp-106');
+      expect(patches.length).to.equal(2);
+      expect(patches[0].selector).to.equal('h4.title');
+      expect(patches[1].selector).to.equal('h5.subtitle');
+      expect(patches[0].valueFormat).to.equal('hast');
+      expect(patches[1].valueFormat).to.equal('hast');
+    });
+
+    it('should not use text valueFormat for heading-order-invalid', () => {
+      const hastValue = {
+        type: 'root',
+        children: [
+          { type: 'element', tagName: 'h2', children: [{ type: 'text', value: 'Heading' }] },
+        ],
+      };
+
+      const suggestion = {
+        getId: () => 'sugg-108',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: 'Fix heading hierarchy.',
+          transformRules: {
+            action: 'replaceWith',
+            selector: 'h4',
+            valueFormat: 'hast',
+            value: hastValue,
+          },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-108');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      // Verify it uses HAST format, not text
+      expect(patch.valueFormat).to.equal('hast');
+      expect(patch.value).to.be.an('object');
+      expect(patch.value).to.deep.equal(hastValue);
+    });
+
+    it('should include currValue when currentValue is not null for heading-empty', () => {
+      const suggestion = {
+        getId: () => 'sugg-109',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-empty',
+          recommendedAction: 'New Heading Text',
+          currentValue: 'Old Heading',
+          transformRules: {
+            action: 'replace',
+            selector: 'h2.empty',
+          },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-109');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch.currValue).to.equal('Old Heading');
+      expect(patch.value).to.equal('New Heading Text');
+    });
+
+    it('should not include currValue when currentValue is null', () => {
+      const suggestion = {
+        getId: () => 'sugg-110',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-empty',
+          recommendedAction: 'New Heading Text',
+          currentValue: null,
+          transformRules: {
+            action: 'replace',
+            selector: 'h2.empty',
+          },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-110');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch.currValue).to.be.undefined;
+      expect(patch.value).to.equal('New Heading Text');
+    });
+
     it('should return empty array for heading-missing-h1 without transformRules', () => {
       const suggestion = {
         getId: () => 'sugg-999',

package/test/mappers/readability-mapper.test.js

@@ -261,7 +261,6 @@ describe('ReadabilityMapper', () => {
         getData: () => ({
           textPreview: 'Lorem ipsum...',
           url: 'https://www.website.com',
-          scrapedAt: '2025-09-20T06:21:12.584Z',
           transformRules: {
             value: 'Tech enthusiasts keep up with the latest tech news...',
             op: 'replace',
@@ -290,14 +289,13 @@ describe('ReadabilityMapper', () => {
       expect(patch.lastUpdated).to.be.a('number');
     });
 
-    it('should create patch with scrapedAt timestamp', () => {
+    it('should create patch with updatedAt timestamp', () => {
       const suggestion = {
         getId: () => 'sugg-456',
-        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getUpdatedAt: () => '2025-09-20T06:21:12.584Z',
         getData: () => ({
           textPreview: 'Original text...',
           url: 'https://www.example.com',
-          scrapedAt: '2025-09-20T06:21:12.584Z',
           transformRules: {
             value: 'Improved readability text',
             op: 'replace',

package/test/mappers/toc-mapper.test.js

@@ -340,7 +340,6 @@ describe('TocMapper', () => {
             selector: 'h1#main-heading',
             valueFormat: 'hast',
             value: tocValue,
-            scrapedAt: '2025-12-06T06:27:04.663Z',
           },
         }),
       };