@adobe/spacecat-shared-tokowaka-client 1.5.0 → 1.5.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [@adobe/spacecat-shared-tokowaka-client-v1.5.2](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.5.1...@adobe/spacecat-shared-tokowaka-client-v1.5.2) (2026-01-21)
+
+
+### Bug Fixes
+
+* create and update tokowaka config api ([#1273](https://github.com/adobe/spacecat-shared/issues/1273)) ([0fb6f4a](https://github.com/adobe/spacecat-shared/commit/0fb6f4aaa1efac18803f3890c86d4fc1bc69009f))
+
+# [@adobe/spacecat-shared-tokowaka-client-v1.5.1](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.5.0...@adobe/spacecat-shared-tokowaka-client-v1.5.1) (2026-01-20)
+
+
+### Bug Fixes
+
+* rename tokowaka to edge-optimize in preview api ([#1269](https://github.com/adobe/spacecat-shared/issues/1269)) ([d40caa4](https://github.com/adobe/spacecat-shared/commit/d40caa46d2bb72506e45081a263f4513fce4ce41))
+
 # [@adobe/spacecat-shared-tokowaka-client-v1.5.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.4.7...@adobe/spacecat-shared-tokowaka-client-v1.5.0) (2026-01-15)
 
 

package/package.json

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

package/src/index.js

@@ -282,12 +282,12 @@ class TokowakaClient {
   }
 
   /**
-   * Creates and uploads domain-level metaconfig to S3
+   * Creates and uploads domain-level metaconfig to S3 if it does not exists
    * Generates a new API key and creates the metaconfig structure
    * @param {string} url - Full URL (used to extract domain)
    * @param {string} siteId - Site ID
    * @param {Object} options - Optional configuration
-   * @param {boolean} options.tokowakaEnabled - Whether to enable Tokowaka (default: true)
+   * @param {boolean} options.enhancements - Whether to enable enhancements (default: true)
    * @returns {Promise<Object>} - Object with s3Path and metaconfig
    */
   async createMetaconfig(url, siteId, options = {}) {
@@ -295,6 +295,12 @@ class TokowakaClient {
       throw this.#createError('URL is required', HTTP_BAD_REQUEST);
     }
 
+    const existingMetaconfig = await this.fetchMetaconfig(url);
+
+    if (existingMetaconfig) {
+      throw this.#createError('Metaconfig already exists for this URL', HTTP_BAD_REQUEST);
+    }
+
     if (!hasText(siteId)) {
       throw this.#createError('Site ID is required', HTTP_BAD_REQUEST);
     }
@@ -305,8 +311,53 @@ class TokowakaClient {
     const metaconfig = {
       siteId,
       apiKeys: [apiKey],
+      tokowakaEnabled: true,
+      enhancements: options.enhancements ?? true,
+      patches: {},
+    };
+
+    const s3Path = await this.uploadMetaconfig(url, metaconfig);
+
+    this.log.info(`Created new Tokowaka metaconfig for ${normalizedHostName} at ${s3Path}`);
+
+    return metaconfig;
+  }
+
+  /**
+   * Updates domain-level metaconfig to S3 if it does not exists
+   * Reuses the same API key and updates the metaconfig structure
+   * @param {string} url - Full URL (used to extract domain)
+   * @param {string} siteId - Site ID
+   * @param {Object} options - Optional configuration
+   * @returns {Promise<Object>} - Object with s3Path and metaconfig
+   */
+  async updateMetaconfig(url, siteId, options = {}) {
+    if (!hasText(url)) {
+      throw this.#createError('URL is required', HTTP_BAD_REQUEST);
+    }
+
+    const existingMetaconfig = await this.fetchMetaconfig(url);
+    if (!existingMetaconfig) {
+      throw this.#createError('Metaconfig does not exist for this URL', HTTP_BAD_REQUEST);
+    }
+
+    if (!hasText(siteId)) {
+      throw this.#createError('Site ID is required', HTTP_BAD_REQUEST);
+    }
+
+    const normalizedHostName = getHostName(url, this.log);
+
+    // dont override api keys
+    // if patches exist, they cannot reset to empty object
+    const metaconfig = {
+      siteId,
+      apiKeys: existingMetaconfig.apiKeys,
       tokowakaEnabled: options.tokowakaEnabled ?? true,
-      enhancements: false,
+      enhancements: options.enhancements ?? true,
+      patches: isNonEmptyObject(options.patches)
+        ? options.patches
+        : (existingMetaconfig.patches ?? {}),
+      ...(options.forceFail && { forceFail: true }),
     };
 
     const s3Path = await this.uploadMetaconfig(url, metaconfig);
@@ -810,8 +861,8 @@ class TokowakaClient {
     }
 
     // TOKOWAKA_EDGE_URL is mandatory for preview
-    const tokowakaEdgeUrl = this.env.TOKOWAKA_EDGE_URL;
-    if (!hasText(tokowakaEdgeUrl)) {
+    const edgeUrl = this.env.TOKOWAKA_EDGE_URL;
+    if (!hasText(edgeUrl)) {
       throw this.#createError(
         'TOKOWAKA_EDGE_URL is required for preview functionality',
         HTTP_INTERNAL_SERVER_ERROR,
@@ -931,7 +982,7 @@ class TokowakaClient {
         previewUrl,
         apiKey,
         forwardedHost,
-        tokowakaEdgeUrl,
+        edgeUrl,
         this.log,
         false,
         options,
@@ -941,7 +992,7 @@ class TokowakaClient {
         previewUrl,
         apiKey,
         forwardedHost,
-        tokowakaEdgeUrl,
+        edgeUrl,
         this.log,
         true,
         options,

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

@@ -25,7 +25,7 @@ function sleep(ms) {
 
 /**
  * Makes an HTTP request with retry logic
- * Retries until max retries are exhausted or x-tokowaka-cache header is present
+ * Retries until max retries are exhausted or x-edge-optimize-cache header is present
  * @param {string} url - URL to fetch
  * @param {Object} options - Fetch options
  * @param {number} maxRetries - Maximum number of retries
@@ -48,10 +48,10 @@ async function fetchWithRetry(url, options, maxRetries, retryDelayMs, log, fetch
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
 
-      // Check for x-tokowaka-cache header - if present, stop retrying
-      const cacheHeader = response.headers.get('x-tokowaka-cache');
+      // Check for x-edge-optimize-cache header - if present, stop retrying
+      const cacheHeader = response.headers.get('x-edge-optimize-cache');
       if (cacheHeader) {
-        log.debug(`Cache header found (x-tokowaka-cache: ${cacheHeader}), stopping retry logic`);
+        log.debug(`Cache header found (x-edge-optimize-cache: ${cacheHeader}), stopping retry logic`);
         return response;
       }
 
@@ -65,7 +65,7 @@ async function fetchWithRetry(url, options, maxRetries, retryDelayMs, log, fetch
       } else {
         // Last attempt without cache header - throw error
         log.error(`Max retries (${maxRetries}) exhausted without cache header`);
-        throw new Error(`Cache header (x-tokowaka-cache) not found after ${maxRetries} retries`);
+        throw new Error(`Cache header (x-edge-optimize-cache) not found after ${maxRetries} retries`);
       }
     } catch (error) {
       log.warn(`Attempt ${attempt} failed for ${fetchType} HTML, error: ${error.message}`);
@@ -86,12 +86,12 @@ async function fetchWithRetry(url, options, maxRetries, retryDelayMs, log, fetch
 }
 
 /**
- * Fetches HTML content from Tokowaka edge with warmup call and retry logic
+ * Fetches HTML content from edge with warmup call and retry logic
  * Makes an initial warmup call, waits, then makes the actual call with retries
  * @param {string} url - Full URL to fetch
- * @param {string} apiKey - Tokowaka API key
+ * @param {string} apiKey - Edge Optimize API key
  * @param {string} forwardedHost - Host to forward in x-forwarded-host header
- * @param {string} tokowakaEdgeUrl - Tokowaka edge URL
+ * @param {string} edgeUrl - Edge URL
  * @param {boolean} isOptimized - Whether to fetch optimized HTML (with preview param)
  * @param {Object} log - Logger instance
  * @param {Object} options - Additional options
@@ -105,7 +105,7 @@ export async function fetchHtmlWithWarmup(
   url,
   apiKey,
   forwardedHost,
-  tokowakaEdgeUrl,
+  edgeUrl,
   log,
   isOptimized = false,
   options = {},
@@ -116,14 +116,14 @@ export async function fetchHtmlWithWarmup(
   }
 
   if (!hasText(apiKey)) {
-    throw new Error('Tokowaka API key is required for fetching HTML');
+    throw new Error('Edge Optimize API key is required for fetching HTML');
   }
 
   if (!hasText(forwardedHost)) {
     throw new Error('Forwarded host is required for fetching HTML');
   }
 
-  if (!hasText(tokowakaEdgeUrl)) {
+  if (!hasText(edgeUrl)) {
     throw new Error('TOKOWAKA_EDGE_URL is not configured');
   }
 
@@ -139,18 +139,18 @@ export async function fetchHtmlWithWarmup(
   // Parse the URL to extract path and construct full URL
   const urlObj = new URL(url);
   const urlPath = urlObj.pathname;
-  let fullUrl = `${tokowakaEdgeUrl}${urlPath}`;
+  let fullUrl = `${edgeUrl}${urlPath}`;
 
   const headers = {
     'x-forwarded-host': forwardedHost,
-    'x-tokowaka-api-key': apiKey,
-    'x-tokowaka-url': urlPath,
+    'x-edge-optimize-api-key': apiKey,
+    'x-edge-optimize-url': urlPath,
   };
 
   if (isOptimized) {
     // Add tokowakaPreview param for optimized HTML
     fullUrl = `${fullUrl}?tokowakaPreview=true`;
-    headers['x-tokowaka-url'] = `${urlPath}?tokowakaPreview=true`;
+    headers['x-edge-optimize-url'] = `${urlPath}?tokowakaPreview=true`;
   }
 
   const fetchOptions = {

package/test/index.test.js

@@ -457,9 +457,12 @@ describe('TokowakaClient', () => {
   });
 
   describe('createMetaconfig', () => {
-    it('should create metaconfig with generated API key and default options', async () => {
+    it('should create the default metaconfig with generated API key', async () => {
       const siteId = 'site-123';
       const url = 'https://www.example.com/page1';
+      const noSuchKeyError = new Error('NoSuchKey');
+      noSuchKeyError.name = 'NoSuchKey';
+      s3Client.send.onFirstCall().rejects(noSuchKeyError);
 
       const result = await client.createMetaconfig(url, siteId);
 
@@ -468,31 +471,47 @@ describe('TokowakaClient', () => {
       expect(result.apiKeys).to.be.an('array').with.lengthOf(1);
       expect(result.apiKeys[0]).to.be.a('string');
       expect(result).to.have.property('tokowakaEnabled', true);
-      expect(result).to.have.property('enhancements', false);
+      expect(result).to.have.property('enhancements', true);
+      expect(result.patches).to.be.empty;
 
       // Verify uploadMetaconfig was called with correct metaconfig
-      expect(s3Client.send).to.have.been.calledOnce;
+      expect(s3Client.send).to.have.been.calledTwice;
       const command = s3Client.send.firstCall.args[0];
       expect(command.input.Bucket).to.equal('test-bucket');
       expect(command.input.Key).to.equal('opportunities/example.com/config');
     });
 
-    it('should create metaconfig with tokowakaEnabled set to false', async () => {
-      const siteId = 'site-123';
-      const url = 'https://example.com';
-
-      const result = await client.createMetaconfig(url, siteId, { tokowakaEnabled: false });
-
-      expect(result).to.have.property('tokowakaEnabled', false);
-      expect(result).to.have.property('enhancements', false);
-      expect(result.apiKeys).to.have.lengthOf(1);
+    it('should throw error if metaconfig exists', async () => {
+      const existingMetaconfig = {
+        siteId: 'site-123',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+      };
+      // Mock fetchMetaconfig to return existing config
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(existingMetaconfig)),
+        },
+      });
+      try {
+        await client.createMetaconfig('https://example.com', 'site-123');
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Metaconfig already exists for this URL');
+        expect(error.status).to.equal(400);
+      }
     });
 
-    it('should create metaconfig with tokowakaEnabled set to true explicitly', async () => {
-      const siteId = 'site-123';
+    it('should create metaconfig with enhancements set to false', async () => {
+      const siteId = 'site-789';
       const url = 'https://example.com';
+      const noSuchKeyError = new Error('NoSuchKey');
+      noSuchKeyError.name = 'NoSuchKey';
+      s3Client.send.onFirstCall().rejects(noSuchKeyError);
 
-      const result = await client.createMetaconfig(url, siteId, { tokowakaEnabled: true });
+      const result = await client.createMetaconfig(url, siteId, { enhancements: false });
 
       expect(result).to.have.property('tokowakaEnabled', true);
       expect(result).to.have.property('enhancements', false);
@@ -509,6 +528,9 @@ describe('TokowakaClient', () => {
     });
 
     it('should throw error if siteId is missing', async () => {
+      const noSuchKeyError = new Error('NoSuchKey');
+      noSuchKeyError.name = 'NoSuchKey';
+      s3Client.send.onFirstCall().rejects(noSuchKeyError);
       try {
         await client.createMetaconfig('https://example.com', '');
         expect.fail('Should have thrown error');
@@ -519,9 +541,11 @@ describe('TokowakaClient', () => {
     });
 
     it('should handle S3 upload failure', async () => {
+      const noSuchKeyError = new Error('NoSuchKey');
+      noSuchKeyError.name = 'NoSuchKey';
+      s3Client.send.onFirstCall().rejects(noSuchKeyError);
       const s3Error = new Error('S3 network error');
-      s3Client.send.rejects(s3Error);
-
+      s3Client.send.onSecondCall().rejects(s3Error);
       try {
         await client.createMetaconfig('https://example.com', 'site-123');
         expect.fail('Should have thrown error');
@@ -534,6 +558,9 @@ describe('TokowakaClient', () => {
     it('should strip www. from domain in metaconfig path', async () => {
       const siteId = 'site-123';
       const url = 'https://www.example.com/some/path';
+      const noSuchKeyError = new Error('NoSuchKey');
+      noSuchKeyError.name = 'NoSuchKey';
+      s3Client.send.onFirstCall().rejects(noSuchKeyError);
 
       await client.createMetaconfig(url, siteId);
 
@@ -542,6 +569,294 @@ describe('TokowakaClient', () => {
     });
   });
 
+  describe('updateMetaconfig', () => {
+    const existingMetaconfig = {
+      siteId: 'site-456',
+      apiKeys: ['existing-api-key-123'],
+      tokowakaEnabled: false,
+      enhancements: false,
+      patches: { 'existing-patch': 'value' },
+    };
+
+    beforeEach(() => {
+      // Mock fetchMetaconfig to return existing config
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(existingMetaconfig)),
+        },
+      });
+      // Mock uploadMetaconfig S3 upload
+      s3Client.send.onSecondCall().resolves();
+    });
+
+    it('should update metaconfig with default options', async () => {
+      const siteId = 'site-789';
+      const url = 'https://www.example.com/page1';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('siteId', siteId);
+      expect(result).to.have.property('apiKeys');
+      expect(result.apiKeys).to.deep.equal(['existing-api-key-123']);
+      expect(result).to.have.property('tokowakaEnabled', true);
+      expect(result).to.have.property('enhancements', true);
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+      expect(result).to.not.have.property('forceFail');
+    });
+
+    it('should update metaconfig with tokowakaEnabled set to false', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { tokowakaEnabled: false });
+
+      expect(result).to.have.property('tokowakaEnabled', false);
+      expect(result).to.have.property('enhancements', true);
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+      expect(result).to.not.have.property('forceFail');
+    });
+
+    it('should update metaconfig with tokowakaEnabled set to true explicitly', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { tokowakaEnabled: true });
+
+      expect(result).to.have.property('tokowakaEnabled', true);
+      expect(result).to.have.property('enhancements', true);
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+    });
+
+    it('should update metaconfig with enhancements set to false', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { enhancements: false });
+
+      expect(result).to.have.property('tokowakaEnabled', true);
+      expect(result).to.have.property('enhancements', false);
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+    });
+
+    it('should update metaconfig with enhancements set to true explicitly', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { enhancements: true });
+
+      expect(result).to.have.property('tokowakaEnabled', true);
+      expect(result).to.have.property('enhancements', true);
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+    });
+
+    it('should override patches when non-empty patches object is provided', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      const newPatches = { 'new-patch': 'new-value', 'another-patch': 'another-value' };
+
+      const result = await client.updateMetaconfig(url, siteId, { patches: newPatches });
+
+      expect(result.patches).to.deep.equal(newPatches);
+      expect(result.patches).to.not.deep.equal({ 'existing-patch': 'value' });
+    });
+
+    it('should preserve existing patches when empty patches object is provided', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { patches: {} });
+
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+    });
+
+    it('should preserve existing patches when patches is undefined', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+    });
+
+    it('should use empty patches object when existing config has no patches and no patches provided', async () => {
+      const configWithoutPatches = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: false,
+        enhancements: false,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithoutPatches)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result.patches).to.deep.equal({});
+    });
+
+    it('should include forceFail when set to true', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { forceFail: true });
+
+      expect(result).to.have.property('forceFail', true);
+    });
+
+    it('should not include forceFail when set to false', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { forceFail: false });
+
+      expect(result).to.not.have.property('forceFail');
+    });
+
+    it('should not include forceFail when undefined', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.not.have.property('forceFail');
+    });
+
+    it('should update metaconfig with multiple options', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      const newPatches = { 'custom-patch': 'custom-value' };
+
+      const result = await client.updateMetaconfig(url, siteId, {
+        tokowakaEnabled: false,
+        enhancements: false,
+        patches: newPatches,
+        forceFail: true,
+      });
+
+      expect(result).to.have.property('tokowakaEnabled', false);
+      expect(result).to.have.property('enhancements', false);
+      expect(result.patches).to.deep.equal(newPatches);
+      expect(result).to.have.property('forceFail', true);
+      expect(result.apiKeys).to.deep.equal(['existing-api-key-123']);
+    });
+
+    it('should preserve apiKeys from existing metaconfig', async () => {
+      const existingWithMultipleKeys = {
+        siteId: 'site-456',
+        apiKeys: ['key-1', 'key-2', 'key-3'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(existingWithMultipleKeys)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result.apiKeys).to.deep.equal(['key-1', 'key-2', 'key-3']);
+    });
+
+    it('should throw error if URL is missing', async () => {
+      try {
+        await client.updateMetaconfig('', 'site-123');
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('URL is required');
+        expect(error.status).to.equal(400);
+      }
+    });
+
+    it('should throw error if siteId is missing', async () => {
+      try {
+        await client.updateMetaconfig('https://example.com', '');
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Site ID is required');
+        expect(error.status).to.equal(400);
+      }
+    });
+
+    it('should throw error if metaconfig does not exist', async () => {
+      const noSuchKeyError = new Error('NoSuchKey');
+      noSuchKeyError.name = 'NoSuchKey';
+      s3Client.send.onFirstCall().rejects(noSuchKeyError);
+
+      try {
+        await client.updateMetaconfig('https://example.com', 'site-123');
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Metaconfig does not exist for this URL');
+        expect(error.status).to.equal(400);
+      }
+    });
+
+    it('should handle S3 upload failure', async () => {
+      const s3Error = new Error('S3 network error');
+      s3Client.send.onSecondCall().rejects(s3Error);
+
+      try {
+        await client.updateMetaconfig('https://example.com', 'site-123');
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('S3 upload failed');
+        expect(error.status).to.equal(500);
+      }
+    });
+
+    it('should strip www. from domain in metaconfig path', async () => {
+      const siteId = 'site-789';
+      const url = 'https://www.example.com/some/path';
+
+      await client.updateMetaconfig(url, siteId);
+
+      const uploadCommand = s3Client.send.secondCall.args[0];
+      expect(uploadCommand.input.Key).to.equal('opportunities/example.com/config');
+    });
+
+    it('should handle metaconfig with null patches', async () => {
+      const configWithNullPatches = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: null,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithNullPatches)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result.patches).to.deep.equal({});
+    });
+
+    it('should handle single patch in options.patches', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      const singlePatch = { 'only-patch': 'only-value' };
+
+      const result = await client.updateMetaconfig(url, siteId, { patches: singlePatch });
+
+      expect(result.patches).to.deep.equal(singlePatch);
+    });
+  });
+
   describe('uploadConfig', () => {
     it('should upload config to S3', async () => {
       const config = {
@@ -1924,7 +2239,7 @@ describe('TokowakaClient', () => {
         status: 200,
         statusText: 'OK',
         headers: {
-          get: (name) => (name === 'x-tokowaka-cache' ? 'HIT' : null),
+          get: (name) => (name === 'x-edge-optimize-cache' ? 'HIT' : null),
         },
         text: async () => '<html><body>Test HTML</body></html>',
       });

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

@@ -744,7 +744,6 @@ Overall, Bulk positions itself as a better choice for sports nutrition through i
               question: 'Old Q?',
               answer: 'Old A.',
             },
-            tokowakaDeployed: 1704884400000,
             transformRules: {
               action: 'appendChild',
               selector: 'main',
@@ -1154,7 +1153,7 @@ Overall, Bulk positions itself as a better choice for sports nutrition through i
     });
   });
 
-  describe('tokowakaDeployed filtering', () => {
+  describe('edgeDeployed filtering', () => {
     it('should always create heading patch even when FAQ already deployed for URL', () => {
       const newSuggestion = {
         getId: () => 'sugg-new-1',

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

@@ -94,7 +94,7 @@ describe('HTML Utils', () => {
         );
         expect.fail('Should have thrown error');
       } catch (error) {
-        expect(error.message).to.equal('Tokowaka API key is required for fetching HTML');
+        expect(error.message).to.equal('Edge Optimize API key is required for fetching HTML');
       }
     });
 
@@ -104,7 +104,7 @@ describe('HTML Utils', () => {
         status: 200,
         statusText: 'OK',
         headers: {
-          get: (name) => (name === 'x-tokowaka-cache' ? 'HIT' : null),
+          get: (name) => (name === 'x-edge-optimize-cache' ? 'HIT' : null),
         },
         text: async () => '<html>Test HTML</html>',
       });
@@ -129,7 +129,7 @@ describe('HTML Utils', () => {
         status: 200,
         statusText: 'OK',
         headers: {
-          get: (name) => (name === 'x-tokowaka-cache' ? 'HIT' : null),
+          get: (name) => (name === 'x-edge-optimize-cache' ? 'HIT' : null),
         },
         text: async () => '<html>Optimized HTML</html>',
       });
@@ -285,7 +285,7 @@ describe('HTML Utils', () => {
       }
     });
 
-    it('should stop retrying when x-tokowaka-cache header is found', async () => {
+    it('should stop retrying when x-edge-optimize-cache header is found', async () => {
       // Warmup succeeds
       fetchStub.onCall(0).resolves({
         ok: true,
@@ -312,7 +312,7 @@ describe('HTML Utils', () => {
         status: 200,
         statusText: 'OK',
         headers: {
-          get: (name) => (name === 'x-tokowaka-cache' ? 'HIT' : null),
+          get: (name) => (name === 'x-edge-optimize-cache' ? 'HIT' : null),
         },
         text: async () => '<html>Cached HTML</html>',
       });
@@ -385,7 +385,7 @@ describe('HTML Utils', () => {
         expect.fail('Should have thrown error');
       } catch (error) {
         expect(error.message).to.include('Failed to fetch original HTML');
-        expect(error.message).to.include('Cache header (x-tokowaka-cache) not found after 2 retries');
+        expect(error.message).to.include('Cache header (x-edge-optimize-cache) not found after 2 retries');
       }
 
       // Should have tried 3 times (initial + 2 retries) plus warmup
@@ -409,7 +409,7 @@ describe('HTML Utils', () => {
         status: 200,
         statusText: 'OK',
         headers: {
-          get: (name) => (name === 'x-tokowaka-cache' ? 'HIT' : null),
+          get: (name) => (name === 'x-edge-optimize-cache' ? 'HIT' : null),
         },
         text: async () => '<html>Cached HTML</html>',
       });