Merge branch 'release/1.11.0'

Author: DianaIonita

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-api-gateway-caching",
-  "version": "1.10.4",
+  "version": "1.11.0",
   "description": "A plugin for the serverless framework which helps with configuring caching for API Gateway endpoints.",
   "main": "src/apiGatewayCachingPlugin.js",
   "scripts": {
@@ -30,10 +30,12 @@
   },
   "devDependencies": {
     "chai": "^4.1.2",
+    "chai-as-promised": "^8.0.1",
     "chance": "^1.0.16",
     "lodash.split": "^4.4.0",
     "mocha": "^10.0.0",
     "mocha-junit-reporter": "^2.0.2",
-    "proxyquire": "^2.1.0"
+    "proxyquire": "^2.1.0",
+    "sinon": "^20.0.0"
   }
 }

package.json

@@ -2,7 +2,7 @@
 
 const ApiGatewayCachingSettings = require('./ApiGatewayCachingSettings');
 const cacheKeyParameters = require('./cacheKeyParameters');
-const updateStageCacheSettings = require('./stageCache');
+const { updateStageCacheSettings } = require('./stageCache');
 const { restApiExists, outputRestApiIdTo } = require('./restApiId');
 
 class ApiGatewayCachingPlugin {
@@ -13,7 +13,7 @@ class ApiGatewayCachingPlugin {
     this.hooks = {
       'before:package:initialize': this.createSettings.bind(this),
       'before:package:finalize': this.updateCloudFormationTemplate.bind(this),
-      'after:aws:deploy:finalize:cleanup': this.updateStage.bind(this),
+      'after:deploy:deploy': this.updateStage.bind(this),
     };
 
     this.defineValidationSchema(serverless);

src/apiGatewayCachingPlugin.js

@@ -1,6 +1,7 @@
 const isEmpty = require('lodash.isempty');
 const { retrieveRestApiId } = require('./restApiId');
 const MAX_PATCH_OPERATIONS_PER_STAGE_UPDATE = 80;
+const BASE_RETRY_DELAY_MS = 500;
 
 String.prototype.replaceAll = function (search, replacement) {
   let target = this;
@@ -194,14 +195,48 @@ const updateStageFor = async (serverless, params, stage, region) => {
     paramsInChunks.push(params);
   }
 
-  for (let index in paramsInChunks) {
-    serverless.cli.log(`[serverless-api-gateway-caching] Updating API Gateway cache settings (${parseInt(index) + 1} of ${paramsInChunks.length}).`);
-    await serverless.providers.aws.request('APIGateway', 'updateStage', paramsInChunks[index], stage, region);
+  for (const [index, chunk] of paramsInChunks.entries()) {
+    serverless.cli.log(`[serverless-api-gateway-caching] Updating API Gateway cache settings (${index + 1} of ${paramsInChunks.length}).`);
+    await applyUpdateStageForChunk(chunk, serverless, stage, region);
   }
 
   serverless.cli.log(`[serverless-api-gateway-caching] Done updating API Gateway cache settings.`);
 }
 
+const applyUpdateStageForChunk = async (chunk, serverless, stage, region) => {
+  const maxRetries = 10;
+  const baseDelay = BASE_RETRY_DELAY_MS;
+  let attempt = 0;
+
+  while (attempt < maxRetries) {
+    try {
+      serverless.cli.log(`[serverless-api-gateway-caching] Updating API Gateway cache settings. Attempt ${attempt + 1}.`);
+      await serverless.providers.aws.request('APIGateway', 'updateStage', chunk, stage, region);
+      return;
+    } catch (error) {
+      // Check for specific error code first, fallback to message check
+      if (
+          (error.code === 'ConflictException' || error.message.includes('A previous change is still in progress'))
+      ) {
+        attempt++;
+        if (attempt >= maxRetries) {
+           serverless.cli.log(`[serverless-api-gateway-caching] Maximum retries (${maxRetries}) reached. Failed to update API Gateway cache settings.`);
+           // Log the full error for better debugging before throwing
+           console.error('[serverless-api-gateway-caching] Final error details:', error);
+           throw new Error(`Failed to update API Gateway cache settings after ${maxRetries} retries: ${error.message}`);
+        }
+        const delay = baseDelay * 2 ** attempt;
+        serverless.cli.log(`[serverless-api-gateway-caching] Retrying (${attempt}/${maxRetries}) after ${delay}ms due to error: ${error.message}`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      } else {
+        console.error('[serverless-api-gateway-caching] Non-retryable error during update:', error);
+        // Throw immediately for non-retryable errors or if string/code doesn't match
+        throw new Error(`Failed to update API Gateway cache settings: ${error.message}`);
+      }
+    }
+  }
+}
+
 const updateStageCacheSettings = async (settings, serverless) => {
   // do nothing if caching settings are not defined
   if (settings.cachingEnabled == undefined) {
@@ -240,4 +275,7 @@ const updateStageCacheSettings = async (settings, serverless) => {
   await updateStageFor(serverless, params, settings.stage, settings.region);
 }
 
-module.exports = updateStageCacheSettings;
+module.exports = {
+  updateStageCacheSettings,
+  applyUpdateStageForChunk
+}

src/stageCache.js

@@ -90,14 +90,16 @@ describe('Creating plugin', () => {
         const serverless = { cli: { log: (message) => { logCalledWith = message } } };
         const restApiIdStub = {
           restApiExists: () => scenario.thereIsARestApi,
-          outputRestApiIdTo: () => outputRestApiIdCalled = true
+          outputRestApiIdTo: () => {}
+        };
+        const stageCacheStub = {
+          updateStageCacheSettings: () => updateStageCacheSettingsCalled = true
         };
-        const stageCacheStub = () => updateStageCacheSettingsCalled = true;
         const ApiGatewayCachingPlugin = proxyquire('../src/apiGatewayCachingPlugin', { './restApiId': restApiIdStub, './stageCache': stageCacheStub });
         const plugin = new ApiGatewayCachingPlugin(serverless, {});
 
-        before(() => {
-          plugin.updateStage();
+        before(async () => {
+          await plugin.updateStage();
         });
 
         it('should log a message', () => {

test/creating-plugin.js

@@ -1,4 +1,4 @@
-const updateStageCacheSettings = require('../../src/stageCache');
+const { updateStageCacheSettings } = require('../../src/stageCache');
 
 const updating_stage_cache_settings = async (settings, serverless) => {
     return await updateStageCacheSettings(settings, serverless);

test/steps/when.js

@@ -1,7 +1,7 @@
 const given = require('../test/steps/given');
 const when = require('../test/steps/when');
 const ApiGatewayCachingSettings = require('../src/ApiGatewayCachingSettings');
-const updateStageCacheSettings = require('../src/stageCache');
+const { updateStageCacheSettings } = require('../src/stageCache');
 const expect = require('chai').expect;
 
 describe('Updating stage cache settings for additional endpoints defined as CloudFormation', () => {

test/updating-stage-cache-settings-for-additional-endpoints.js

@@ -2,8 +2,18 @@ const given = require('../test/steps/given');
 const when = require('../test/steps/when');
 const ApiGatewayCachingSettings = require('../src/ApiGatewayCachingSettings');
 const UnauthorizedCacheControlHeaderStrategy = require('../src/UnauthorizedCacheControlHeaderStrategy');
+const chai = require('chai');
+const sinon = require('sinon');
 const expect = require('chai').expect;
 
+const { applyUpdateStageForChunk } = require('../src/stageCache');
+
+// Use a before block to asynchronously load and configure chai-as-promised
+before(async () => {
+  const chaiAsPromised = await import('chai-as-promised');
+  chai.use(chaiAsPromised.default); // Use .default when importing ESM dynamically
+});
+
 describe('Updating stage cache settings', () => {
   let serverless, settings, requestsToAws, apiGatewayRequest;
   const apiGatewayService = 'APIGateway', updateStageMethod = 'updateStage';
@@ -787,4 +797,102 @@ describe('Updating stage cache settings', () => {
       });
     });
   });
+
+  describe('applyUpdateStageForChunk function', () => {
+    let serverless;
+    let clock;
+    const stage = 'test-stage';
+    const region = 'eu-west-1';
+    const chunk = {
+      restApiId: 'test-api-id',
+      stageName: stage,
+      patchOperations: [{ op: 'replace', path: '/cacheClusterEnabled', value: 'true' }]
+    };
+
+    beforeEach(() => {
+      serverless = given.a_serverless_instance()
+        .forStage(stage)
+        .forRegion(region);
+      clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+      clock.restore();
+      sinon.restore();
+    });
+
+    it('should call aws.request once on success', async () => {
+      const requestStub = sinon.stub(serverless.providers.aws, 'request').resolves();
+
+      await applyUpdateStageForChunk(chunk, serverless, stage, region);
+
+      expect(requestStub.calledOnce).to.be.true;
+      expect(requestStub.getCall(0).args[0]).to.equal('APIGateway');
+      expect(requestStub.getCall(0).args[1]).to.equal('updateStage');
+      expect(requestStub.getCall(0).args[2]).to.deep.equal(chunk);
+      expect(requestStub.getCall(0).args[3]).to.equal(stage);
+      expect(requestStub.getCall(0).args[4]).to.equal(region);
+      expect(serverless._logMessages).to.include('[serverless-api-gateway-caching] Updating API Gateway cache settings. Attempt 1.');
+    });
+
+    it('should retry on ConflictException and succeed on the second attempt', async () => {
+      const conflictError = new Error('A previous change is still in progress');
+      conflictError.code = 'ConflictException';
+
+      // Mock AWS request: fail first, succeed second
+      const requestStub = sinon.stub(serverless.providers.aws, 'request');
+      requestStub.onFirstCall().rejects(conflictError);
+      requestStub.onSecondCall().resolves();
+
+      const promise = applyUpdateStageForChunk(chunk, serverless, stage, region);
+
+      // Advance clock to trigger the retry timeout
+      await clock.tickAsync(1000); // Advance past the first delay (500 * 2^1)
+
+      await promise; // Wait for the function to complete
+
+      expect(requestStub.calledTwice).to.be.true;
+      expect(serverless._logMessages).to.include('[serverless-api-gateway-caching] Updating API Gateway cache settings. Attempt 1.');
+      expect(serverless._logMessages).to.include('[serverless-api-gateway-caching] Retrying (1/10) after 1000ms due to error: A previous change is still in progress');
+      expect(serverless._logMessages).to.include('[serverless-api-gateway-caching] Updating API Gateway cache settings. Attempt 2.');
+    });
+
+    it('should fail after max retries on persistent ConflictException', async () => {
+      const conflictError = new Error('A previous change is still in progress');
+      conflictError.code = 'ConflictException';
+      const maxRetries = 10; // As defined in the function
+
+      // Mock AWS request to always fail with ConflictException
+      const requestStub = sinon.stub(serverless.providers.aws, 'request').rejects(conflictError);
+
+      const promise = applyUpdateStageForChunk(chunk, serverless, stage, region);
+
+      // Advance clock past all retry delays
+      for (let i = 1; i <= maxRetries; i++) {
+        await clock.tickAsync(500 * (2 ** i) + 10); // Ensure delay is passed
+      }
+
+      // Assert the promise rejects with the correct error
+      await expect(promise).to.be.rejectedWith(`Failed to update API Gateway cache settings after ${maxRetries} retries: ${conflictError.message}`);
+      expect(requestStub.callCount).to.equal(maxRetries);
+      expect(serverless._logMessages).to.include(`[serverless-api-gateway-caching] Maximum retries (${maxRetries}) reached. Failed to update API Gateway cache settings.`);
+    });
+
+    it('should fail immediately on non-retryable error', async () => {
+      const otherError = new Error('Some other API Gateway error');
+      otherError.code = 'BadRequestException'; // Example non-retryable code
+
+      // Mock AWS request to fail with a non-retryable error
+      const requestStub = sinon.stub(serverless.providers.aws, 'request').rejects(otherError);
+      const errorSpy = sinon.spy(console, 'error'); // Spy on console.error
+
+      const promise = applyUpdateStageForChunk(chunk, serverless, stage, region);
+
+      // Assert the promise rejects immediately
+      await expect(promise).to.be.rejectedWith(`Failed to update API Gateway cache settings: ${otherError.message}`);
+      expect(requestStub.calledOnce).to.be.true; // Should not retry
+      expect(errorSpy.calledWith('[serverless-api-gateway-caching] Non-retryable error during update:', otherError)).to.be.true;
+      errorSpy.restore(); // Restore the spy
+    });
+  });
 });