Apply internal adjustments for Socket Mode support

Author: seratch

slack_bolt/app/app.py

@@ -30,7 +30,6 @@
 from slack_bolt.listener_matcher.listener_matcher import ListenerMatcher
 from slack_bolt.logger import get_bolt_app_logger, get_bolt_logger
 from slack_bolt.logger.messages import (
-    error_signing_secret_not_found,
     warning_client_prioritized_and_token_skipped,
     warning_token_skipped,
     error_auth_test_failure,
@@ -106,9 +105,6 @@ def __init__(
         signing_secret = signing_secret or os.environ.get("SLACK_SIGNING_SECRET")
         token = token or os.environ.get("SLACK_BOT_TOKEN")
 
-        if signing_secret is None or signing_secret == "":
-            raise BoltError(error_signing_secret_not_found())
-
         self._name: str = name or inspect.stack()[1].filename.split(os.path.sep)[-1]
         self._signing_secret: str = signing_secret
 

slack_bolt/app/async_app.py

@@ -23,7 +23,6 @@
 )
 from slack_bolt.error import BoltError
 from slack_bolt.logger.messages import (
-    error_signing_secret_not_found,
     warning_client_prioritized_and_token_skipped,
     warning_token_skipped,
     error_token_required,
@@ -115,9 +114,6 @@ def __init__(
         signing_secret = signing_secret or os.environ.get("SLACK_SIGNING_SECRET")
         token = token or os.environ.get("SLACK_BOT_TOKEN")
 
-        if signing_secret is None or signing_secret == "":
-            raise BoltError(error_signing_secret_not_found())
-
         self._name: str = name or inspect.stack()[1].filename.split(os.path.sep)[-1]
         self._signing_secret: str = signing_secret
         self._verification_token: Optional[str] = verification_token or os.environ.get(

slack_bolt/logger/messages.py

@@ -10,14 +10,6 @@
 # -------------------------------
 
 
-def error_signing_secret_not_found() -> str:
-    return (
-        "Signing secret not found, so could not initialize the Bolt app."
-        "Copy your Signing Secret from the Basic Information page "
-        "and then store it in a new environment variable"
-    )
-
-
 def error_client_invalid_type() -> str:
     return "`client` must be a slack_sdk.web.WebClient"
 

slack_bolt/middleware/request_verification/async_request_verification.py

@@ -14,7 +14,7 @@ async def async_process(
         resp: BoltResponse,
         next: Callable[[], Awaitable[BoltResponse]],
     ) -> BoltResponse:
-        if self._can_skip(req.body):
+        if self._can_skip(req.mode, req.body):
             return await next()
 
         body = req.raw_body

slack_bolt/middleware/request_verification/request_verification.py

@@ -21,7 +21,7 @@ def __init__(self, signing_secret: str):
     def process(
         self, *, req: BoltRequest, resp: BoltResponse, next: Callable[[], BoltResponse],
     ) -> BoltResponse:
-        if self._can_skip(req.body):
+        if self._can_skip(req.mode, req.body):
             return next()
 
         body = req.raw_body
@@ -36,8 +36,10 @@ def process(
     # -----------------------------------------
 
     @staticmethod
-    def _can_skip(body: Dict[str, Any]) -> bool:
-        return body is not None and body.get("ssl_check") == "1"
+    def _can_skip(mode: str, body: Dict[str, Any]) -> bool:
+        return mode == "socket_mode" or (
+            body is not None and body.get("ssl_check") == "1"
+        )
 
     @staticmethod
     def _build_error_response() -> BoltResponse:

slack_bolt/request/async_request.py

@@ -1,12 +1,15 @@
 from typing import Dict, Optional, Union, Any, Sequence
 
 from slack_bolt.context.async_context import AsyncBoltContext
+from slack_bolt.error import BoltError
 from slack_bolt.request.async_internals import build_async_context
 from slack_bolt.request.internals import (
     parse_query,
     parse_body,
     build_normalized_headers,
     extract_content_type,
+    error_message_raw_body_required_in_http_mode,
+    error_message_unknown_request_body_type,
 )
 
 
@@ -19,31 +22,42 @@ class AsyncBoltRequest:
     context: AsyncBoltContext
     lazy_only: bool
     lazy_function_name: Optional[str]
+    mode: str  # either "http" or "socket_mode"
 
     def __init__(
         self,
         *,
-        body: str,
+        body: Union[str, dict],
         query: Optional[Union[str, Dict[str, str], Dict[str, Sequence[str]]]] = None,
         headers: Optional[Dict[str, Union[str, Sequence[str]]]] = None,
         context: Optional[Dict[str, str]] = None,
+        mode: str = "http",  # either "http" or "socket_mode"
     ):
         """Request to a Bolt app.
 
-        :param body: The raw request body (only plain text is supported)
+        :param body: The raw request body (only plain text is supported for "http" mode)
         :param query: The query string data in any data format.
         :param headers: The request headers.
         :param context: The context in this request.
+        :param mode: The mode used for this request. (either "http" or "socket_mode")
         """
-        self.raw_body = body
+        if mode == "http" and not isinstance(body, str):
+            raise BoltError(error_message_raw_body_required_in_http_mode())
+        self.raw_body = body if mode == "http" else ""
         self.query = parse_query(query)
         self.headers = build_normalized_headers(headers)
         self.content_type = extract_content_type(self.headers)
-        self.body = parse_body(self.raw_body, self.content_type)
+        if isinstance(body, str):
+            self.body = parse_body(self.raw_body, self.content_type)
+        elif isinstance(body, dict):
+            self.body = body
+        else:
+            raise BoltError(error_message_unknown_request_body_type())
         self.context = build_async_context(
             AsyncBoltContext(context if context else {}), self.body
         )
         self.lazy_only = self.headers.get("x-slack-bolt-lazy-only", [False])[0]
         self.lazy_function_name = self.headers.get(
             "x-slack-bolt-lazy-function-name", [None]
         )[0]
+        self.mode = mode

slack_bolt/request/internals.py

@@ -159,3 +159,11 @@ def build_normalized_headers(
                     f"Unsupported type ({type(value)}) of element in headers ({headers})"
                 )
     return normalized_headers  # type: ignore
+
+
+def error_message_raw_body_required_in_http_mode() -> str:
+    return "`body` must be a raw string data when running in the HTTP server mode"
+
+
+def error_message_unknown_request_body_type() -> str:
+    return "`body` must be either str or dict"

slack_bolt/request/request.py

@@ -1,12 +1,15 @@
 from typing import Dict, Optional, Union, Any, Sequence
 
 from slack_bolt.context.context import BoltContext
+from slack_bolt.error import BoltError
 from slack_bolt.request.internals import (
     parse_query,
     parse_body,
     build_normalized_headers,
     build_context,
     extract_content_type,
+    error_message_raw_body_required_in_http_mode,
+    error_message_unknown_request_body_type,
 )
 
 
@@ -19,29 +22,41 @@ class BoltRequest:
     context: BoltContext
     lazy_only: bool
     lazy_function_name: Optional[str]
+    mode: str  # either "http" or "socket_mode"
 
     def __init__(
         self,
         *,
-        body: str,
+        body: Union[str, dict],
         query: Optional[Union[str, Dict[str, str], Dict[str, Sequence[str]]]] = None,
         headers: Optional[Dict[str, Union[str, Sequence[str]]]] = None,
         context: Optional[Dict[str, str]] = None,
+        mode: str = "http",  # either "http" or "socket_mode"
     ):
         """Request to a Bolt app.
 
-        :param body: The raw request body (only plain text is supported)
+        :param body: The raw request body (only plain text is supported for "http" mode)
         :param query: The query string data in any data format.
         :param headers: The request headers.
         :param context: The context in this request.
+        :param mode: The mode used for this request. (either "http" or "socket_mode")
         """
-        self.raw_body = body
+        if mode == "http" and not isinstance(body, str):
+            raise BoltError(error_message_raw_body_required_in_http_mode())
+        self.raw_body = body if mode == "http" else ""
         self.query = parse_query(query)
         self.headers = build_normalized_headers(headers)
         self.content_type = extract_content_type(self.headers)
-        self.body = parse_body(self.raw_body, self.content_type)
+        if isinstance(body, str):
+            self.body = parse_body(self.raw_body, self.content_type)
+        elif isinstance(body, dict):
+            self.body = body
+        else:
+            raise BoltError(error_message_unknown_request_body_type())
+
         self.context = build_context(BoltContext(context if context else {}), self.body)
         self.lazy_only = self.headers.get("x-slack-bolt-lazy-only", [False])[0]
         self.lazy_function_name = self.headers.get(
             "x-slack-bolt-lazy-function-name", [None]
         )[0]
+        self.mode = mode