serverless.yml

service: socless-slack
unresolvedVariablesNotificationMode: error

provider:
  name: aws
  runtime: python3.9
  variableSyntax: "\\${{([ ~:a-zA-Z0-9._\\'\",\\-\\/\\(\\)]+?)}}"
  stage: ${{opt:stage}}
  region: ${{opt:region}}
  versionFunctions: false
  memorySize: 128
  timeout: 120
  role: ${{cf:${{self:custom.socless}}.LambdaExecutionRoleArn}}
  environment:
    SOCLESS_VAULT: ${{cf:${{self:custom.socless}}.SoclessVault}}
    RESULTS_TABLE: ${{cf:${{self:custom.socless}}.ExecutionResultsTable}}
    SOCLESS_RESULTS_TABLE: ${{cf:${{self:custom.socless}}.ExecutionResultsTable}}
    SOCLESS_MESSAGE_RESPONSE_TABLE: ${{cf:${{self:custom.socless}}.MessageResponsesTable}}
    MESSAGE_RESPONSES_TABLE: ${{cf:${{self:custom.socless}}.MessageResponsesTable}}
    SOCLESS_BOT_TOKEN: ${{ssm:/socless/slack/bot_token~true}} # default token if none specified via lambda args at runtime
    CACHE_USERS_TABLE:
      Ref: SlackUsernamesTable
    # Add Bot Tokens to the environment vars for multi-bot support.
    # <BOT_NAME>_TOKEN can be used in playbooks at runtime as "token" : "{{env('TSIRT_TOKEN')}}"
    # To enable interactivity, you will also need to add the bot signing secret under the
    # `SlackEndpoint` lambda function below
    TSIRT_TOKEN: ${{ssm:/socless/slack/bot_token~true}}

  vpc:
    securityGroupIds:
      - ${{cf:${{self:custom.socless}}.LambdaVpcSG}}
    subnetIds:
      - ${{cf:${{self:custom.socless}}.PrivateFunctionSubnet}}
  apiGateway:
    restApiId: ${{cf:${{self:custom.socless}}.APIGatewayID}}
    restApiRootResourceId: ${{cf:${{self:custom.socless}}.APIGatewayRootResourceId}}

plugins:
  - sls-apb

package:
  individually: true

custom:
  socless: socless-${{self:provider.stage}}
  statesRole: ${{cf:socless-${{self:provider.stage}}.StatesExecutionRoleArn}}
  core:
    SetInvestigationStatus: ${{cf:socless-${{self:provider.stage}}.SetInvestigationStatus}}
    MergeParallelOutput: ${{cf:socless-${{self:provider.stage}}.MergeParallelOutput}}
  playbooks:
    - socless_slack_integration_test
    - socless_slack_e2e_interaction_test

  slash_command: ${{ssm:/socless/slack/slash_command}}
  concurrencyAmount:
    dev: 1
    stage: 1
    prod: 3
    sandbox: 1

functions:
  SlackEndpoint:
    handler: lambda_function.lambda_handler
    name: _socless_slack_endpoint
    description: Receives messages from Slack
    memorySize: 128
    timeout: 30
    environment:
      AWAIT_MESSAGE_RESPONSE_ARN: ${{cf:${{self:custom.socless}}.AwaitMessageResponseActivity}}
      HELP_TEXT: ${{ssm:/socless/slack_endpoint/help_text~true}}
      # Add bot Signing Secret for multi-bot support.
      # <BOT_NAME>_SECRET, where <BOT_NAME> is the same name passed via query params
      # to the slack endpoint: <endpoint>/<stage/slack?bot=<BOT_NAME>
      TSIRT_SECRET: ${{ssm:/socless/slack/signing_secret~true}}
    package:
      artifact: .archives/functions/_slack_endpoint.zip
    provisionedConcurrency: ${{self:custom.concurrencyAmount.${{self:provider.stage}}}}
    events:
      - http:
          path: /slack
          method: post
          cors: true

  WebApi:
    handler: lambda_function.lambda_handler
    name: socless_slack_web_api_request
    description: Socless Slack integration for any API call
    package:
      artifact: .archives/functions/web_api.zip

  FindUser:
    handler: lambda_function.lambda_handler
    name: socless_slack_find_user
    description: Socless Slack integration find a user's profile in Slack
    package:
      artifact: .archives/functions/find_user.zip

  PromptForConfirmation:
    handler: lambda_function.lambda_handler
    name: _socless_slack_prompt_for_confirmation
    description: Socless Slack integration to prompt a user for a Yes/No confirmation
    environment:
      SAVE_MESSAGE_RESPONSE_MACHINE: ${{cf:${{self:custom.socless}}.SaveMessageResponseTaskToken}}
    package:
      artifact: .archives/functions/prompt_for_confirmation.zip

  PromptForResponse:
    handler: lambda_function.lambda_handler
    name: _socless_slack_prompt_for_response
    description: Socless Slack integration to prompt a user for a text-based response
    environment:
      SAVE_MESSAGE_RESPONSE_MACHINE: ${{cf:${{self:custom.socless}}.SaveMessageResponseTaskToken}}
      SLACK_SLASH_COMMAND: ${{self:custom.slash_command}}
    package:
      artifact: .archives/functions/prompt_for_response.zip

  SendMessage:
    handler: lambda_function.lambda_handler
    name: socless_slack_send_message
    description: Socless Slack integration to send messages without expecting responses
    package:
      artifact: .archives/functions/send_message.zip

  SendDialog:
    handler: lambda_function.lambda_handler
    name: _socless_slack_send_dialog
    description: Send a dialog into Slack
    environment:
      SAVE_MESSAGE_RESPONSE_MACHINE: ${{cf:${{self:custom.socless}}.SaveMessageResponseTaskToken}}
    package:
      artifact: .archives/functions/send_dialog.zip
    # Note: when removing this provisionedConcurrency config for this function,
    # be sure to also remove the `:provisioned` prefix in Outputs.SendDialog
    # and re-deploy all playbooks using the output to ensure the right version
    # of the lambda function is referenced
    provisionedConcurrency: ${{self:custom.concurrencyAmount.${{self:provider.stage}}}}

  CreateChannel:
    handler: lambda_function.lambda_handler
    name: socless_slack_create_channel
    description: Create a slack channel
    package:
      artifact: .archives/functions/create_channel.zip

  CheckIfUserInChannel:
    handler: lambda_function.lambda_handler
    name: socless_slack_check_user_in_channel
    description: Check if user is in a channel
    package:
      artifact: .archives/functions/check_user_in_channel.zip

  SetChannelTopic:
    handler: lambda_function.lambda_handler
    name: socless_slack_set_channel_topic
    description: Set topic for a channel
    package:
      artifact: .archives/functions/set_channel_topic.zip

  InviteToChannel:
    handler: lambda_function.lambda_handler
    name: socless_slack_invite_to_channel
    description: invite a slack member to channel
    package:
      artifact: .archives/functions/invite_to_channel.zip

  ListChannels:
    handler: lambda_function.lambda_handler
    name: socless_slack_list_channels
    description: list all channels
    package:
      artifact: .archives/functions/list_channels.zip

  UpdateCachedUsers:
    handler: lambda_function.lambda_handler
    name: socless_slack_update_cached_users
    description: Socless Slack integration that populates the dynamodb cache
    memorySize: 192
    timeout: 500
    package:
      artifact: .archives/functions/_update_cached_users.zip

  UploadFile:
    handler: lambda_function.lambda_handler
    name: socless_slack_upload_file
    description: Socless Slack integration to send messages without expecting responses
    package:
      artifact: .archives/functions/upload_file.zip

resources:
  - ${{file(resources/dynamodb.yml)}} # Cache usernames dynamodb table
  # Uncomment this to deploy the slack test case with your code
  # - Resources:
  #     SoclessSlackIntegrationTestcase:
  #       Type: "AWS::SSM::Parameter"
  #       Properties:
  #         Description:
  #           Fn::Sub: "Input for ${{self:service}}'s integration test playbook"
  #         Name: /socless/slack/integration_test_input
  #         Type: String
  #         Value: ${{file(playbooks/socless_slack_integration_test/test_case_json.txt)}}

  - Outputs:
      WebApi:
        Description:
          ARN of Socless Slack generic 
        Value:
          Fn::Sub: ${WebApiLambdaFunction.Arn}

      FindUser:
        Description:
          ARN of Socless Slack integration to find a Slack User based on
          their username
        Value:
          Fn::Sub: ${FindUserLambdaFunction.Arn}

      PromptForConfirmation:
        Description:
          ARN of Socless Slack integration to prompt a user for a Yes/No
          confirmation
        Value:
          Fn::Sub: ${PromptForConfirmationLambdaFunction.Arn}

      PromptForResponse:
        Description:
          ARN of Socless Slack integration to prompt a user for a text-based
          response
        Value:
          Fn::Sub: ${PromptForResponseLambdaFunction.Arn}

      SendMessage:
        Description:
          ARN of Socless Slack integration to send messages without expecting
          responses
        Value:
          Fn::Sub: ${SendMessageLambdaFunction.Arn}

      SendDialog:
        Description:
          ARN of Socless Slack integration for ingesting Socless integration
          commands from Slack
        Value:
          # Output the Arn for the provisionedConcurrency version of the function,
          # the `:provisioned` suffix is auto-created by the
          # serverless framework and carries the actual provisioned concurrency
          Fn::Sub: ${SendDialogLambdaFunction.Arn}:provisioned

      CreateChannel:
        Description: ARN of Socless Slack integration to create a channel
        Value:
          Fn::Sub: ${CreateChannelLambdaFunction.Arn}

      CheckIfUserInChannel:
        Description: ARN of Socless Slack integration to check if user is in a channel
        Value:
          Fn::Sub: ${CheckIfUserInChannelLambdaFunction.Arn}

      SetChannelTopic:
        Description: ARN of Socless Slack integration to set topic for a channel
        Value:
          Fn::Sub: ${SetChannelTopicLambdaFunction.Arn}

      InviteToChannel:
        Description: ARN of Socless Slack integration to invite a member to channel
        Value:
          Fn::Sub: ${InviteToChannelLambdaFunction.Arn}

      ListChannels:
        Description: ARN of Socless Slack integration to list all channels
        Value:
          Fn::Sub: ${ListChannelsLambdaFunction.Arn}

      UpdateCachedUsers:
        Description:
          ARN of Socless Slack integration that populates the dynamodb
          cache
        Value:
          Fn::Sub: ${UpdateCachedUsersLambdaFunction.Arn}

      UploadFile:
        Description: ARN of Socless Slack integration to send a file
        Value:
          Fn::Sub: ${UploadFileLambdaFunction.Arn}