Merge branch 'develop' into tmp/1698101531/main

Author: Connor Robertson

integration/combination/test_connectors.py

@@ -62,6 +62,7 @@ def tearDown(self):
             ("combination/connector_appsync_api_to_lambda",),
             ("combination/connector_appsync_to_lambda",),
             ("combination/connector_appsync_to_table",),
+            ("combination/connector_appsync_to_eventbus",),
             ("combination/connector_function_to_function",),
             ("combination/connector_restapi_to_function",),
             ("combination/connector_httpapi_to_function",),

integration/resources/expected/combination/connector_appsync_to_eventbus.json

@@ -0,0 +1,38 @@
+[
+  {
+    "LogicalResourceId": "ApiKey",
+    "ResourceType": "AWS::AppSync::ApiKey"
+  },
+  {
+    "LogicalResourceId": "ApiSchema",
+    "ResourceType": "AWS::AppSync::GraphQLSchema"
+  },
+  {
+    "LogicalResourceId": "AppSyncApi",
+    "ResourceType": "AWS::AppSync::GraphQLApi"
+  },
+  {
+    "LogicalResourceId": "AppSyncEventBusDataSource",
+    "ResourceType": "AWS::AppSync::DataSource"
+  },
+  {
+    "LogicalResourceId": "AppSyncSayHelloResolver",
+    "ResourceType": "AWS::AppSync::Resolver"
+  },
+  {
+    "LogicalResourceId": "ConnectorPolicy",
+    "ResourceType": "AWS::IAM::ManagedPolicy"
+  },
+  {
+    "LogicalResourceId": "EventBridgeRole",
+    "ResourceType": "AWS::IAM::Role"
+  },
+  {
+    "LogicalResourceId": "EventBus",
+    "ResourceType": "AWS::Events::EventBus"
+  },
+  {
+    "LogicalResourceId": "TriggerFunction",
+    "ResourceType": "AWS::Lambda::Function"
+  }
+]

integration/resources/templates/combination/connector_appsync_to_eventbus.yaml

@@ -0,0 +1,192 @@
+Resources:
+  EventBus:
+    Type: AWS::Events::EventBus
+    Properties:
+      Name: !Sub "${AWS::StackName}-EventBus"
+
+  EventBridgeRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: '2012-10-17'
+        Statement:
+        - Effect: Allow
+          Action:
+          - sts:AssumeRole
+          Principal:
+            Service:
+            - appsync.amazonaws.com
+            - lambda.amazonaws.com
+
+  AppSyncApi:
+    Type: AWS::AppSync::GraphQLApi
+    Properties:
+      Name: AppSyncApi
+      AuthenticationType: API_KEY
+
+  ApiSchema:
+    Type: AWS::AppSync::GraphQLSchema
+    Properties:
+      ApiId: !GetAtt AppSyncApi.ApiId
+      Definition: |
+        type EntryDetails {
+          ErrorCode: String
+          ErrorMessage: String
+          EventId: String!
+        }
+
+        type PutEventsResult {
+          Entries: [EntryDetails!]!
+          FailedEntry: Int
+        }
+
+        type Query {
+          sayHello: PutEventsResult!
+        }
+
+        schema {
+          query: Query
+        }
+
+  AppSyncEventBusDataSource:
+    Type: AWS::AppSync::DataSource
+    Properties:
+      ApiId: !GetAtt AppSyncApi.ApiId
+      Name: AppSyncEventBusDataSource
+      Type: AMAZON_EVENTBRIDGE
+      ServiceRoleArn: !GetAtt EventBridgeRole.Arn
+      EventBridgeConfig:
+        EventBusArn: !GetAtt 'EventBus.Arn'
+
+  AppSyncSayHelloResolver:
+    DependsOn: ApiSchema
+    Type: AWS::AppSync::Resolver
+    Properties:
+      ApiId: !GetAtt AppSyncApi.ApiId
+      TypeName: Query
+      FieldName: sayHello
+      DataSourceName: !GetAtt AppSyncEventBusDataSource.Name
+      Runtime:
+        Name: APPSYNC_JS
+        RuntimeVersion: 1.0.0
+      Code: |
+        import { util } from '@aws-appsync/utils';
+        export function request(ctx) {
+          return {
+            "operation" : "PutEvents",
+            "events" : [{
+              "source": "com.mycompany.myapp",
+              "detail": {
+                "key1" : "value1",
+                "key2" : "value2"
+              },
+              "resources": ["Resource1", "Resource2"],
+              "detailType": "myDetailType"
+            }]
+          }
+        }
+
+        export function response(ctx) {
+          if(ctx.error)
+            util.error(ctx.error.message, ctx.error.type, ctx.result)
+          else
+            return ctx.result
+        }
+
+  Connector:
+    Type: AWS::Serverless::Connector
+    Properties:
+      Source:
+        Id: AppSyncEventBusDataSource
+      Destination:
+        Id: EventBus
+      Permissions:
+      - Write
+
+  ApiKey:
+    Type: AWS::AppSync::ApiKey
+    Properties:
+      ApiId: !GetAtt AppSyncApi.ApiId
+
+  TriggerFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Role: !GetAtt EventBridgeRole.Arn
+      Environment:
+        Variables:
+          API_KEY: !GetAtt ApiKey.ApiKey
+          GRAPHQL_URL: !GetAtt AppSyncApi.GraphQLUrl
+          EventBusName: !Ref EventBus
+      Runtime: nodejs16.x
+      Handler: index.handler
+      InlineCode: |
+        const https = require("https");
+
+        exports.handler = async () => {
+          const queries = {
+            sayHello: /* GraphQL */ `
+              query {
+                sayHello {
+                  Entries {
+                    ErrorCode
+                    EventId
+                    ErrorMessage
+                  }
+                  FailedEntry
+                }
+              }
+            `,
+          };
+
+          const fetch = async (url, options) =>
+            new Promise((resolve, reject) => {
+              const req = https.request(url, options, (res) => {
+                const body = [];
+                res.on("data", (chunk) => body.push(chunk));
+                res.on("end", () => {
+                  const resString = Buffer.concat(body).toString();
+                  resolve(resString);
+                });
+              });
+              req.on("error", (err) => {
+                reject(err);
+              });
+              req.on("timeout", () => {
+                req.destroy();
+                reject(new Error("Request time out"));
+              });
+              req.write(options.body);
+              req.end();
+            });
+
+          const makeRequest = async (queryName) => {
+            const options = {
+              method: "POST",
+              headers: {
+                "x-api-key": process.env.API_KEY,
+              },
+              body: JSON.stringify({ query: queries[queryName] }),
+              timeout: 600000, // ms
+            };
+
+            const response = await fetch(process.env.GRAPHQL_URL, options);
+            let body = JSON.parse(response);
+            const data = body.data?.[queryName];
+            
+            if (body.errors !== undefined) {
+              throw JSON.stringify(body.errors);
+            }
+            
+            if (data.FailedEntry != null || data.ErrorCode != null ) {
+              throw new Error(
+                `${queryName} error: failed to send event to eventbus ${process.env.EventBusName}`);
+            }
+            
+            return body.data;
+          };
+
+          await makeRequest("sayHello");
+        };
+
+Metadata:
+  SamTransformTest: true

pytest.ini

@@ -20,3 +20,5 @@ filterwarnings =
     ignore:The --rsyncdir command line argument and rsyncdirs config variable are deprecated.:DeprecationWarning
     # Pytest warnings
     ignore::pytest.PytestUnraisableExceptionWarning
+    # https://github.com/urllib3/urllib3/blob/main/src/urllib3/poolmanager.py#L313
+    ignore::DeprecationWarning:urllib3.*:

samtranslator/internal/schema_source/aws_serverless_function.py

@@ -626,7 +626,7 @@ class Properties(BaseModel):
     SnapStart: Optional[SnapStart] = prop("SnapStart")
     RuntimeManagementConfig: Optional[RuntimeManagementConfig] = prop("RuntimeManagementConfig")
     Tags: Optional[Tags] = prop("Tags")
-    PropagateTags: Optional[bool]  # TODO: add docs
+    PropagateTags: Optional[bool] = prop("PropagateTags")
     Timeout: Optional[Timeout] = prop("Timeout")
     Tracing: Optional[Tracing] = prop("Tracing")
     VersionDescription: Optional[PassThroughProp] = prop("VersionDescription")
@@ -656,7 +656,7 @@ class Globals(BaseModel):
         ["AWS::Lambda::Function", "Properties", "Environment"],
     )
     Tags: Optional[Tags] = prop("Tags")
-    PropagateTags: Optional[bool]  # TODO: add docs
+    PropagateTags: Optional[bool] = prop("PropagateTags")
     Tracing: Optional[Tracing] = prop("Tracing")
     KmsKeyArn: Optional[KmsKeyArn] = prop("KmsKeyArn")
     Layers: Optional[Layers] = prop("Layers")

samtranslator/internal/schema_source/common.py

@@ -99,3 +99,4 @@ class ResourceAttributes(BaseModel):
     Metadata: Optional[PassThroughProp]
     UpdateReplacePolicy: Optional[PassThroughProp]
     Condition: Optional[PassThroughProp]
+    IgnoreGlobals: Optional[Union[str, List[str]]]

samtranslator/model/connector_profiles/profiles.json

@@ -790,6 +790,23 @@
             }
           }
         }
+      },
+      "AWS::Events::EventBus": {
+        "Type": "AWS_IAM_ROLE_MANAGED_POLICY",
+        "Properties": {
+          "SourcePolicy": true,
+          "AccessCategories": {
+            "Write": {
+              "Statement": [
+                {
+                  "Effect": "Allow",
+                  "Action": ["events:PutEvents"],
+                  "Resource": ["%{Destination.Arn}"]
+                }
+              ]
+            }
+          }
+        }
       }
     },
     "AWS::AppSync::GraphQLApi": {

samtranslator/open_api/open_api.py

@@ -518,6 +518,10 @@ def openapi(self) -> Dict[str, Any]:
 
         if self.security_schemes:
             self._doc.setdefault("components", Py27Dict())
+            if not self._doc["components"]:
+                # explicitly set to dict to account for scenario where
+                # 'components' is explicitly set to None
+                self._doc["components"] = Py27Dict()
             self._doc["components"]["securitySchemes"] = self.security_schemes
 
         if self.info:

samtranslator/plugins/globals/globals.py

@@ -1,6 +1,7 @@
-from typing import Any, Dict, List
+import copy
+from typing import Any, Dict, List, Optional, Union
 
-from samtranslator.model.exceptions import ExceptionWithMessage
+from samtranslator.model.exceptions import ExceptionWithMessage, InvalidResourceAttributeTypeException
 from samtranslator.public.intrinsics import is_intrinsics
 from samtranslator.public.sdk.resource import SamResourceType
 from samtranslator.swagger.swagger import SwaggerEditor
@@ -99,7 +100,7 @@ class Globals:
         SamResourceType.Function.value: ["RuntimeManagementConfig"],
     }
 
-    def __init__(self, template) -> None:  # type: ignore[no-untyped-def]
+    def __init__(self, template: Dict[str, Any]) -> None:
         """
         Constructs an instance of this object
 
@@ -111,12 +112,57 @@ def __init__(self, template) -> None:  # type: ignore[no-untyped-def]
         # Sort the names for stability in list ordering
         self.supported_resource_section_names.sort()
 
-        self.template_globals = {}
+        self.template_globals: Dict[str, GlobalProperties] = {}
 
         if self._KEYWORD in template:
             self.template_globals = self._parse(template[self._KEYWORD])  # type: ignore[no-untyped-call]
 
-    def merge(self, resource_type, resource_properties):  # type: ignore[no-untyped-def]
+    def get_template_globals(
+        self, logical_id: str, resource_type: str, ignore_globals: Optional[Union[str, List[str]]]
+    ) -> "GlobalProperties":
+        """
+        Get template globals but remove globals based on IgnoreGlobals attribute.
+
+        :param string logical_id: LogicalId of the resource
+        :param string resource_type: Type of the resource (Ex: AWS::Serverless::Function)
+        :param dict ignore_globals: IgnoreGlobals resource attribute. It can be either 1) "*" string value
+            or list of string value, each value should be a valid property in Globals section
+        :return dict: processed template globals
+        """
+        if not ignore_globals:
+            return self.template_globals[resource_type]
+
+        if isinstance(ignore_globals, str) and ignore_globals == "*":
+            return GlobalProperties({})
+
+        if isinstance(ignore_globals, list):
+            global_props: GlobalProperties = copy.deepcopy(self.template_globals[resource_type])
+            for key in ignore_globals:
+                if key not in global_props.global_properties:
+                    raise InvalidResourceAttributeTypeException(
+                        logical_id,
+                        "IgnoreGlobals",
+                        None,
+                        f"Resource {logical_id} has invalid resource attribute 'IgnoreGlobals' on item '{key}'.",
+                    )
+                del global_props.global_properties[key]
+            return global_props
+
+        # We raise exception for any non "*" or non-list input
+        raise InvalidResourceAttributeTypeException(
+            logical_id,
+            "IgnoreGlobals",
+            None,
+            f"Resource {logical_id} has invalid resource attribute 'IgnoreGlobals'.",
+        )
+
+    def merge(
+        self,
+        resource_type: str,
+        resource_properties: Dict[str, Any],
+        logical_id: str = "",
+        ignore_globals: Optional[Union[str, List[str]]] = None,
+    ) -> Any:
         """
         Adds global properties to the resource, if necessary. This method is a no-op if there are no global properties
         for this resource type
@@ -130,12 +176,12 @@ def merge(self, resource_type, resource_properties):  # type: ignore[no-untyped-
             # Nothing to do. Return the template unmodified
             return resource_properties
 
-        global_props = self.template_globals[resource_type]
+        global_props = self.get_template_globals(logical_id, str(resource_type), ignore_globals)
 
-        return global_props.merge(resource_properties)
+        return global_props.merge(resource_properties)  # type: ignore[no-untyped-call]
 
     @classmethod
-    def del_section(cls, template):  # type: ignore[no-untyped-def]
+    def del_section(cls, template: Dict[str, Any]) -> None:
         """
         Helper method to delete the Globals section altogether from the template