Harden CloudFormation variable and Ref resolvers

lib/configuration/variables/sources/instance-dependent/get-cf.js

@@ -51,7 +51,7 @@ module.exports = (serverlessInstance) => {
       })();
 
       if (!result) return { value: null };
-      const outputs = result.Stacks[0].Outputs;
+      const outputs = result.Stacks[0].Outputs || [];
       const output = outputs.find((x) => x.OutputKey === outputLogicalId);
 
       return { value: output ? output.OutputValue : null };

lib/plugins/aws/utils/resolve-cf-import-value.js

@@ -4,10 +4,10 @@ const ServerlessError = require('../../../serverless-error');
 
 async function resolveCfImportValue(provider, name, sdkParams = {}) {
   return provider.request('CloudFormation', 'listExports', sdkParams).then((result) => {
-    const targetExportMeta = result.Exports.find((exportMeta) => exportMeta.Name === name);
+    const targetExportMeta = (result.Exports || []).find((exportMeta) => exportMeta.Name === name);
     if (targetExportMeta) return targetExportMeta.Value;
     if (result.NextToken) {
-      return resolveCfImportValue(provider, name, { NextToken: result.NextToken });
+      return resolveCfImportValue(provider, name, { ...sdkParams, NextToken: result.NextToken });
     }
 
     throw new ServerlessError(

lib/plugins/aws/utils/resolve-cf-ref-value.js

@@ -4,22 +4,24 @@ const ServerlessError = require('../../../serverless-error');
 
 async function resolveCfRefValue(provider, resourceLogicalId, sdkParams = {}) {
   return provider
-    .request(
-      'CloudFormation',
-      'listStackResources',
-      Object.assign(sdkParams, { StackName: provider.naming.getStackName() })
-    )
+    .request('CloudFormation', 'listStackResources', {
+      ...sdkParams,
+      StackName: provider.naming.getStackName(),
+    })
     .then((result) => {
-      const targetStackResource = result.StackResourceSummaries.find(
+      const targetStackResource = (result.StackResourceSummaries || []).find(
         (stackResource) => stackResource.LogicalResourceId === resourceLogicalId
       );
       if (targetStackResource) return targetStackResource.PhysicalResourceId;
       if (result.NextToken) {
-        return resolveCfRefValue(provider, resourceLogicalId, { NextToken: result.NextToken });
+        return resolveCfRefValue(provider, resourceLogicalId, {
+          ...sdkParams,
+          NextToken: result.NextToken,
+        });
       }
 
       throw new ServerlessError(
-        `Could not resolve Ref with name ${resourceLogicalId}. Are you sure this value matches one resource logical ID ?`,
+        `Could not resolve Ref with name ${resourceLogicalId}. Are you sure this value matches a resource logical ID?`,
         'CF_REF_RESOLUTION'
       );
     });

test/unit/lib/configuration/variables/sources/instance-dependent/get-cf.test.js

@@ -20,6 +20,7 @@ describe('test/unit/lib/configuration/variables/sources/instance-dependent/get-c
         existing: '${cf:existing.someOutput}',
         existingInRegion: '${cf(eu-west-1):existing.someOutput}',
         noOutput: '${cf:existing.unrecognizedOutput, null}',
+        noOutputs: '${cf:noOutputs.someOutput, null}',
         noStack: '${cf:notExisting.someOutput, null}',
         missingAddress: '${cf:}',
         invalidAddress: '${cf:invalid}',
@@ -39,6 +40,9 @@ describe('test/unit/lib/configuration/variables/sources/instance-dependent/get-c
               ],
             };
           }
+          if (StackName === 'noOutputs') {
+            return { Stacks: [{}] };
+          }
           if (StackName === 'notExisting') {
             throw Object.assign(new Error('Stack with id not-existing does not exist'), {
               code: 'AWS_CLOUD_FORMATION_DESCRIBE_STACKS_VALIDATION_ERROR',
@@ -73,6 +77,12 @@ describe('test/unit/lib/configuration/variables/sources/instance-dependent/get-c
     if (variablesMeta.get('custom\0noOutput')) throw variablesMeta.get('custom\0noOutput').error;
     expect(configuration.custom.noOutput).to.equal(null);
   });
+  it('should resolve null when stack has no outputs', () => {
+    if (variablesMeta.get('custom\0noOutputs')) {
+      throw variablesMeta.get('custom\0noOutputs').error;
+    }
+    expect(configuration.custom.noOutputs).to.equal(null);
+  });
   it('should resolve null on missing stack', () => {
     if (variablesMeta.get('custom\0noStack')) throw variablesMeta.get('custom\0noStack').error;
     expect(configuration.custom.noStack).to.equal(null);

test/unit/lib/plugins/aws/utils/resolve-cf-import-value.test.js

@@ -22,4 +22,36 @@ describe('#resolveCfImportValue', () => {
     const result = await resolveCfImportValue(provider, 'exportName');
     expect(result).to.equal('exportValue');
   });
+
+  it('should continue pagination when a page has no exports', async () => {
+    const requests = [];
+    const sdkParams = { SomeParam: 'kept' };
+    const provider = {
+      request: async (service, method, params) => {
+        requests.push({ service, method, params });
+        if (!params.NextToken) return { NextToken: 'next-page' };
+        return {
+          Exports: [
+            {
+              Name: 'exportName',
+              Value: 'exportValue',
+            },
+          ],
+        };
+      },
+    };
+
+    const result = await resolveCfImportValue(provider, 'exportName', sdkParams);
+
+    expect(result).to.equal('exportValue');
+    expect(sdkParams).to.deep.equal({ SomeParam: 'kept' });
+    expect(requests).to.deep.equal([
+      { service: 'CloudFormation', method: 'listExports', params: { SomeParam: 'kept' } },
+      {
+        service: 'CloudFormation',
+        method: 'listExports',
+        params: { SomeParam: 'kept', NextToken: 'next-page' },
+      },
+    ]);
+  });
 });

test/unit/lib/plugins/aws/utils/resolve-cf-ref-value.test.js

@@ -25,4 +25,65 @@ describe('#resolveCfRefValue', () => {
     const result = await resolveCfRefValue(provider, 'myDB');
     expect(result).to.equal('stack-name-db-id');
   });
+
+  it('should continue pagination when a page has no stack resources', async () => {
+    const requests = [];
+    const sdkParams = { SomeParam: 'kept' };
+    const provider = {
+      naming: {
+        getStackName: () => 'stack-name',
+      },
+      request: async (service, method, params) => {
+        requests.push({ service, method, params });
+        if (!params.NextToken) return { NextToken: 'next-page' };
+        return {
+          StackResourceSummaries: [
+            {
+              LogicalResourceId: 'myDB',
+              PhysicalResourceId: 'stack-name-db-id',
+            },
+          ],
+        };
+      },
+    };
+
+    const result = await resolveCfRefValue(provider, 'myDB', sdkParams);
+
+    expect(result).to.equal('stack-name-db-id');
+    expect(sdkParams).to.deep.equal({ SomeParam: 'kept' });
+    expect(requests).to.deep.equal([
+      {
+        service: 'CloudFormation',
+        method: 'listStackResources',
+        params: { SomeParam: 'kept', StackName: 'stack-name' },
+      },
+      {
+        service: 'CloudFormation',
+        method: 'listStackResources',
+        params: { SomeParam: 'kept', NextToken: 'next-page', StackName: 'stack-name' },
+      },
+    ]);
+  });
+
+  it('should report a clear error when no resource matches', async () => {
+    const provider = {
+      naming: {
+        getStackName: () => 'stack-name',
+      },
+      request: async () => ({ StackResourceSummaries: [] }),
+    };
+
+    let error;
+    try {
+      await resolveCfRefValue(provider, 'missingResource');
+    } catch (caughtError) {
+      error = caughtError;
+    }
+
+    expect(error).to.have.property(
+      'message',
+      'Could not resolve Ref with name missingResource. Are you sure this value matches a resource logical ID?'
+    );
+    expect(error).to.have.property('code', 'CF_REF_RESOLUTION');
+  });
 });