@adobe/spacecat-shared-tokowaka-client 1.5.1 → 1.5.3

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [@adobe/spacecat-shared-tokowaka-client-v1.5.3](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.5.2...@adobe/spacecat-shared-tokowaka-client-v1.5.3) (2026-01-21)
+
+
+### Bug Fixes
+
+* update tokowaka config ([#1275](https://github.com/adobe/spacecat-shared/issues/1275)) ([06cedcd](https://github.com/adobe/spacecat-shared/commit/06cedcd3d6f5956d895f7dedb7579d2eefffe58e))
+
+# [@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)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-tokowaka-client",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "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,59 @@ class TokowakaClient {
     const metaconfig = {
       siteId,
       apiKeys: [apiKey],
-      tokowakaEnabled: options.tokowakaEnabled ?? true,
-      enhancements: options.enhancements ?? false,
+      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 hasForceFail = options.forceFail !== undefined
+      || existingMetaconfig.forceFail !== undefined;
+    const forceFail = options.forceFail
+      ?? existingMetaconfig.forceFail
+      ?? false;
+
+    const metaconfig = {
+      siteId,
+      apiKeys: existingMetaconfig.apiKeys,
+      tokowakaEnabled: options.tokowakaEnabled ?? existingMetaconfig.tokowakaEnabled ?? true,
+      enhancements: options.enhancements ?? existingMetaconfig.enhancements ?? true,
+      patches: isNonEmptyObject(options.patches)
+        ? options.patches
+        : (existingMetaconfig.patches ?? {}),
+      ...(hasForceFail && { forceFail }),
     };
 
     const s3Path = await this.uploadMetaconfig(url, metaconfig);

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,583 @@ 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']);
+      // Should preserve existing metaconfig values when options not provided
+      expect(result).to.have.property('tokowakaEnabled', false);
+      expect(result).to.have.property('enhancements', false);
+      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', false);
+      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', false);
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+      expect(result).to.not.have.property('forceFail');
+    });
+
+    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', false);
+      expect(result).to.have.property('enhancements', false);
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+      expect(result).to.not.have.property('forceFail');
+    });
+
+    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', 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 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 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.have.property('forceFail', false);
+    });
+
+    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 use forceFail as false when options.forceFail is null and existingMetaconfig has no forceFail', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { forceFail: null });
+
+      expect(result).to.have.property('forceFail', false);
+    });
+
+    it('should preserve existingMetaconfig forceFail when options.forceFail is null', async () => {
+      const configWithForceFail = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+        forceFail: true,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithForceFail)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { forceFail: null });
+
+      expect(result).to.have.property('forceFail', true);
+    });
+
+    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);
+    });
+
+    it('should preserve existing patches when options.patches is null', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { patches: null });
+
+      expect(result.patches).to.deep.equal({ 'existing-patch': 'value' });
+    });
+
+    it('should preserve tokowakaEnabled=true from existingMetaconfig when options not provided', async () => {
+      const configWithTokowakaEnabled = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: false,
+        patches: {},
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithTokowakaEnabled)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('tokowakaEnabled', true);
+    });
+
+    it('should preserve enhancements=true from existingMetaconfig when options not provided', async () => {
+      const configWithEnhancements = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: false,
+        enhancements: true,
+        patches: {},
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithEnhancements)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('enhancements', true);
+    });
+
+    it('should default tokowakaEnabled to true when not in existingMetaconfig or options', async () => {
+      const configWithoutTokowakaEnabled = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        enhancements: false,
+        patches: {},
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithoutTokowakaEnabled)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('tokowakaEnabled', true);
+    });
+
+    it('should default enhancements to true when not in existingMetaconfig or options', async () => {
+      const configWithoutEnhancements = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: false,
+        patches: {},
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithoutEnhancements)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('enhancements', true);
+    });
+
+    it('should preserve forceFail=true from existingMetaconfig when options not provided', async () => {
+      const configWithForceFail = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+        forceFail: true,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithForceFail)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('forceFail', true);
+    });
+
+    it('should override existingMetaconfig forceFail when explicitly set to false in options', async () => {
+      const configWithForceFail = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+        forceFail: true,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithForceFail)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId, { forceFail: false });
+
+      expect(result).to.have.property('forceFail', false);
+    });
+
+    it('should override existingMetaconfig forceFail when explicitly set to true in options', async () => {
+      const configWithoutForceFail = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+        forceFail: false,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithoutForceFail)),
+        },
+      });
+
+      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 preserve forceFail=false from existingMetaconfig when options not provided', async () => {
+      const configWithForceFail = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+        forceFail: false,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithForceFail)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('forceFail', false);
+    });
+
+    it('should override existingMetaconfig tokowakaEnabled=false when explicitly set to true', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      // existingMetaconfig has tokowakaEnabled: false
+
+      const result = await client.updateMetaconfig(url, siteId, { tokowakaEnabled: true });
+
+      expect(result).to.have.property('tokowakaEnabled', true);
+    });
+
+    it('should override existingMetaconfig enhancements=false when explicitly set to true', async () => {
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+      // existingMetaconfig has enhancements: false
+
+      const result = await client.updateMetaconfig(url, siteId, { enhancements: true });
+
+      expect(result).to.have.property('enhancements', true);
+    });
+
+    it('should handle case where options.forceFail and existingMetaconfig.forceFail are both true', async () => {
+      const configWithForceFail = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+        forceFail: true,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithForceFail)),
+        },
+      });
+
+      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 handle case where options.forceFail and existingMetaconfig.forceFail are both false', async () => {
+      const configWithForceFail = {
+        siteId: 'site-456',
+        apiKeys: ['existing-api-key-123'],
+        tokowakaEnabled: true,
+        enhancements: true,
+        patches: {},
+        forceFail: false,
+      };
+      s3Client.send.onFirstCall().resolves({
+        Body: {
+          transformToString: sinon.stub().resolves(JSON.stringify(configWithForceFail)),
+        },
+      });
+
+      const siteId = 'site-789';
+      const url = 'https://example.com';
+
+      const result = await client.updateMetaconfig(url, siteId);
+
+      expect(result).to.have.property('forceFail', false);
+    });
+  });
+
   describe('uploadConfig', () => {
     it('should upload config to S3', async () => {
       const config = {