bisslog-flask 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

bisslog_flask/builder/builder_flask_app_manager.py

@@ -0,0 +1,371 @@
+"""
+Module for generating a Flask application boilerplate from Bisslog metadata and use case code.
+
+This builder analyzes declared metadata (e.g., triggers) and discovered use case implementations,
+and generates the corresponding Flask code—including HTTP routes, WebSocket endpoints, security
+configuration, and runtime setup.
+
+The generated code is returned as a full Python script and can be written to a file (e.g.,
+`flask_app.py`).
+"""
+
+from typing import Optional, Callable
+import json
+
+from bisslog_schema import read_full_service_metadata
+from bisslog_schema.eager_import_module_or_package import EagerImportModulePackage
+from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerWebsocket
+from bisslog_schema.setup import get_setup_metadata
+from bisslog_schema.use_case_code_inspector.use_case_code_metadata import UseCaseCodeInfo, \
+    UseCaseCodeInfoClass, UseCaseCodeInfoObject
+
+from .static_python_construct_data import StaticPythonConstructData
+
+
+class BuilderFlaskAppManager:
+    """
+    Flask application builder for Bisslog-based services.
+
+    This class dynamically generates Flask code based on user-declared metadata and
+    the implementation of use cases discovered in the source tree. It supports HTTP
+    and WebSocket triggers, integrates runtime setup from decorators, and configures
+    environment-based security.
+
+    The result is a complete Flask application scaffold that can be directly executed
+    or used as a starting point for further customization.
+    """
+
+    def __init__(self, eager_importer: Callable[[str], None]):
+        self._eager_importer = eager_importer
+
+
+    def _get_bisslog_setup(self, infra_path: Optional[str]) -> Optional[StaticPythonConstructData]:
+        """
+        Retrieves the Bisslog setup call for the 'flask' runtime, if defined.
+
+        This inspects the global Bisslog configuration and returns the corresponding
+        setup function call code for Flask.
+
+        Returns
+        -------
+        Optional[StaticPythonConstructData]
+            The setup code and imports, or None if no setup was declared.
+        """
+        self._eager_importer(infra_path)
+        setup_metadata = get_setup_metadata()
+        if setup_metadata is None:
+            return None
+
+        if setup_metadata.setup_function is not None:
+            n_params = setup_metadata.setup_function.n_params
+            if n_params == 0:
+                build = f"{setup_metadata.setup_function.function_name}()"
+            elif n_params == 1:
+                build = f"{setup_metadata.setup_function.function_name}(\"flask\")"
+            else:
+                build = (f"{setup_metadata.setup_function.function_name}(\"flask\")"
+                         "  # TODO: change this")
+            return StaticPythonConstructData(
+                importing={setup_metadata.setup_function.module:
+                               {setup_metadata.setup_function.function_name}},
+                build=build,
+            )
+        custom_runtime_setup = setup_metadata.runtime.get("flask", None)
+        if custom_runtime_setup is not None:
+            return StaticPythonConstructData(
+                importing={custom_runtime_setup.module:
+                               {custom_runtime_setup.function_name}},
+                build=f"{custom_runtime_setup.function_name}()"
+            )
+        return None
+
+    @staticmethod
+    def _generate_security_code() -> StaticPythonConstructData:
+        """
+        Generates Flask configuration code for secret keys using environment variables.
+
+        Returns
+        -------
+        StaticPythonConstructData
+            Code that assigns `SECRET_KEY` and `JWT_SECRET_KEY` to the Flask app.
+        """
+        build = """
+if "SECRET_KEY" in os.environ:
+    app.config["SECRET_KEY"] = os.environ["SECRET_KEY"]
+if "JWT_SECRET_KEY" in os.environ:
+    app.config["JWT_SECRET_KEY"] = os.environ["JWT_SECRET_KEY"]
+"""
+        return StaticPythonConstructData(build=build)
+
+    @staticmethod
+    def _generate_use_case_code_build(use_case_code_info: UseCaseCodeInfo):
+        """
+        Prepares the use case callable to be used in HTTP or WebSocket routes.
+
+        If the use case is a class, an instance is created. If it's an object, it's referenced.
+
+        Parameters
+        ----------
+        use_case_code_info : UseCaseCodeInfo
+            Static metadata about the use case implementation.
+
+        Returns
+        -------
+        Tuple[str, StaticPythonConstructData]
+            - Name of the callable reference (e.g., variable or instance).
+            - Generated setup code and required imports.
+        """
+        importing = {"flask": {"request"}, "bisslog.utils.mapping": {"Mapper"}}
+        starting_build = ""
+        if isinstance(use_case_code_info, UseCaseCodeInfoClass):
+            importing[use_case_code_info.module] = {use_case_code_info.class_name}
+            uc_callable = f"{use_case_code_info.name}_uc"
+            starting_build += f"{uc_callable} = {use_case_code_info.class_name}()"
+        elif isinstance(use_case_code_info, UseCaseCodeInfoObject):
+            importing[use_case_code_info.module] = {use_case_code_info.var_name}
+            uc_callable = use_case_code_info.var_name
+        else:
+            raise ValueError("Unsupported UseCaseCodeInfo type")
+        return uc_callable, StaticPythonConstructData(build=starting_build, importing=importing)
+
+    @staticmethod
+    def _generate_use_case_code_http_trigger(
+            use_case_key: str, uc_callable: str, use_case_code_info: UseCaseCodeInfo,
+            trigger_info: TriggerHttp, identifier: int) -> StaticPythonConstructData:
+        """
+        Generates the code for a use case with an HTTP trigger.
+
+        Parameters
+        ----------
+        use_case_key : str
+            Name used to identify the use case route.
+        use_case_code_info : UseCaseCodeInfo
+            Static code metadata for the specific use case.
+        trigger_info : TriggerHttp
+            Metadata of the HTTP trigger.
+
+        Returns
+        -------
+        StaticPythonConstructData
+            The generated code for the HTTP trigger.
+        """
+        imports = {
+            "flask": {"jsonify"}
+        }
+        starting_build = ""
+        mapper_code_lines = []
+        if trigger_info.mapper is not None:
+            mapper_name = f"{use_case_code_info.name}_mapper_{identifier}"
+            starting_build += (f"\n{mapper_name} = Mapper(name=\"{use_case_key}_mapper\", "
+                               f"base={json.dumps(trigger_info.mapper)})")
+            mapper_code_lines.append(f"""
+    res_map = {mapper_name}.map({{
+        "path_query": route_vars,
+        "body": request.get_json(silent=True) or {{}},
+        "params": request.args.to_dict(),
+        "headers": request.headers,
+    }})""")
+        method = trigger_info.method.upper()
+        flask_path = (trigger_info.path or f"/{use_case_key}").replace("{", "<").replace("}", ">")
+        handler_name = f"{use_case_key}_handler_{identifier}"
+
+        lines = [
+            f'@app.route("{flask_path}", methods=["{method}"])',
+        ]
+
+        if use_case_code_info.is_coroutine:
+            lines.append(f"async def {handler_name}(**route_vars):")
+        else:
+            lines.append(f"def {handler_name}(**route_vars):")
+
+        if not mapper_code_lines:
+            lines.append("    kwargs = {}")
+            lines.append("    kwargs.update(route_vars)")
+            lines.append("    kwargs.update(request.get_json(silent=True) or {})")
+            lines.append("    kwargs.update(request.args.to_dict())")
+            lines.append("    kwargs.update(dict(request.headers))")
+            var_to_unpack = "kwargs"
+        else:
+            lines.extend(mapper_code_lines)
+            var_to_unpack = "res_map"
+
+        if use_case_code_info.is_coroutine:
+            lines.append(f'    result = await {uc_callable}(**{var_to_unpack})')
+        else:
+            lines.append(f'    result = {uc_callable}(**{var_to_unpack})\n')
+
+        lines.append('    return jsonify(result)\n')
+
+        return StaticPythonConstructData(build=starting_build,
+                                         body="\n".join(lines), importing=imports)
+
+    @staticmethod
+    def _generate_use_case_code_websocket_trigger(
+            use_case_key: str,
+            uc_callable: str,
+            use_case_code_info: UseCaseCodeInfo,
+            trigger_info: TriggerWebsocket,
+            identifier: int
+    ) -> StaticPythonConstructData:
+        """
+        Generates the code for a use case with a WebSocket trigger using flask-sock.
+
+        Parameters
+        ----------
+        use_case_key : str
+            The identifier of the use case.
+        uc_callable : str
+            The callable name to invoke.
+        use_case_code_info : UseCaseCodeInfo
+            Info about where the use case is defined.
+        trigger_info : TriggerWebsocket
+            Metadata describing the trigger.
+        identifier : int
+            An integer used to ensure uniqueness of function names.
+
+        Returns
+        -------
+        StaticPythonConstructData
+            Code and imports needed for WebSocket registration.
+        """
+        route_key = trigger_info.route_key or f"{use_case_key}.default"
+        handler_name = f"{use_case_key}_ws_handler_{identifier}"
+        mapper_decl = ""
+
+        imports = {
+            use_case_code_info.module: {use_case_code_info.name},
+            "flask_sock": {"Sock"},
+            "flask": {"request", "jsonify"},
+            "bisslog.utils.mapping": {"Mapper"},
+            "json": None
+        }
+
+        if trigger_info.mapper:
+            mapper_var = f"{use_case_key}_ws_mapper_{identifier}"
+            mapper_json = json.dumps(trigger_info.mapper)
+            mapper_decl = (f'\n{mapper_var} = Mapper(name="{use_case_key}_ws_mapper",'
+                           f' base={mapper_json})')
+
+            mapper_code = f"""
+            try:
+                body = json.loads(data)
+            except Exception:
+                body = {{}}
+            res_map = {mapper_var}.map({{
+                "route_key": "{route_key}",
+                "connection_id": request.headers.get("Sec-WebSocket-Key"),
+                "headers": request.headers,
+                "body": body
+            }})
+            response = {uc_callable}(**res_map)
+    """
+
+        else:
+            # fallback: pass entire raw message
+            mapper_code = f"""
+            try:
+                payload = json.loads(data)
+            except Exception:
+                payload = {{}}
+            response = {uc_callable}(**payload)
+    """
+
+        build = f"""
+    @sock.route("/ws/{route_key}")
+    def {handler_name}(ws):
+        while True:
+            data = ws.receive()
+            if data is None:
+                break;  # Client disconnected
+    {mapper_code}
+            if response is not None:
+                ws.send(response)
+    """
+
+        return StaticPythonConstructData(
+            importing=imports,
+            build=(mapper_decl + build)
+        )
+
+    def __call__(self,
+                 metadata_file: Optional[str] = None,
+                 use_cases_folder_path: Optional[str] = None,
+                 infra_path: Optional[str] = None,
+                 *,
+                 encoding: str = "utf-8",
+                 secret_key: Optional[str] = None,
+                 jwt_secret_key: Optional[str] = None,
+                 **kwargs) -> str:
+        """
+        Main entry point for generating the full Flask application code.
+
+        This method orchestrates metadata loading, trigger processing, and Flask code generation
+        (HTTP routes, WebSocket handlers, runtime setup, security config). The resulting app code
+        is returned as a ready-to-write Python string.
+
+        Parameters
+        ----------
+        metadata_file : str, optional
+            Path to the YAML or JSON metadata file.
+        use_cases_folder_path : str, optional
+            Path to the folder where use case implementations are located.
+        infra_path : str, optional
+            Path to additional infrastructure or adapter code.
+        encoding : str, default="utf-8"
+            Encoding used to read the metadata file.
+        secret_key : str, optional
+            secret key for Flask configuration.
+        jwt_secret_key : str, optional
+            JWT secret key for Flask configuration.
+        **kwargs
+            Additional keyword arguments (currently unused).
+
+        Returns
+        -------
+        str
+            The complete Flask application source code as a string.
+        """
+        full_service_metadata = read_full_service_metadata(
+            metadata_file=metadata_file,
+            use_cases_folder_path=use_cases_folder_path,
+            encoding=encoding
+        )
+        service_info = full_service_metadata.declared_metadata
+        use_cases = full_service_metadata.discovered_use_cases
+
+        res = StaticPythonConstructData(
+            importing={"flask": {"Flask"}, "os": None},
+            build="app = Flask(__name__)"
+        )
+        res += self._get_bisslog_setup(infra_path)
+
+        res += self._generate_security_code()
+
+        # Use cases
+        for use_case_key in service_info.use_cases:
+            use_case_info: UseCaseInfo = service_info.use_cases[use_case_key]
+            use_case_code_info: UseCaseCodeInfo = use_cases[use_case_key]
+            triggers_http = [t for t in use_case_info.triggers
+                             if isinstance(t.options, TriggerHttp)]
+            triggers_ws = [t for t in use_case_info.triggers
+                           if isinstance(t.options, TriggerWebsocket)]
+            triggers_flask = triggers_http + triggers_ws
+            if len(triggers_flask) == 0:
+                continue
+            uc_callable, res_uc = self._generate_use_case_code_build(use_case_code_info)
+            res += res_uc
+            for i, trigger in enumerate(triggers_flask):
+                if isinstance(trigger.options, TriggerHttp):
+                    res += self._generate_use_case_code_http_trigger(
+                        use_case_key, uc_callable, use_case_code_info, trigger.options, i
+                    )
+                elif isinstance(trigger.options, TriggerWebsocket):
+                    res += self._generate_use_case_code_websocket_trigger(
+                        use_case_key, uc_callable, use_case_code_info, trigger.options, i
+                    )
+        res += StaticPythonConstructData(body='\nif __name__ == "__main__":\n'
+                                              '    app.run(debug=True, host="0.0.0.0")')
+        return res.generate_boiler_plate_flask()
+
+
+bisslog_flask_builder = BuilderFlaskAppManager(EagerImportModulePackage(("src.infra", "infra")))

bisslog_flask/builder/static_python_construct_data.py

@@ -0,0 +1,172 @@
+"""
+Module defining the response structure for AWS Lambda handler code generation.
+
+This module provides a dataclass that encapsulates the components produced during
+AWS Lambda handler code generation, including the function body, optional setup code,
+and required import statements.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, Set
+
+
+
+@dataclass
+class StaticPythonConstructData:
+    """
+    Response structure for generated AWS Lambda handler components.
+
+    This dataclass represents the output of a code generator that produces AWS Lambda
+    handler functions. It contains the function body as a string, any optional setup/build
+    logic, and the necessary import statements grouped by module.
+
+    Attributes
+    ----------
+    body : Optional[str]
+        The body of the Lambda handler function as a Python code string.
+    build : Optional[str]
+        Optional setup or preconstruction code to include before the function body.
+    importing : Dict[str, Set[str]]
+        A mapping of module names to sets of symbols to import from them.
+
+        This structure assumes simple `from module import symbol` semantics.
+
+        Examples
+        --------
+        {
+            "typing": {"List", "Optional"},
+            "os": {"path", "environ"}
+        }
+
+    extra : Dict[str, Any]
+        Optional extra data provided by the generator.
+    """
+    body: Optional[str] = None
+    build: Optional[str] = None
+    importing: Dict[str, Set[str]] = field(default_factory=dict)
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    def add_imports(self, new_imports: Dict[str, Set[str]]) -> None:
+        """
+        Adds new import statements to the existing import dictionary.
+
+        Parameters
+        ----------
+        new_imports : Dict[str, Set[str]]
+            A dictionary of module names and symbols to import.
+        """
+        for module, symbols in new_imports.items():
+            if module not in self.importing:
+                self.importing[module] = set()
+            self.importing[module].update(symbols)
+
+    @staticmethod
+    def _generate_imports_string(imports: Dict[str, Set[str]]) -> str:
+        """
+        Generates a string representing import statements.
+
+        Parameters
+        ----------
+        imports : Dict[str, Set[str]]
+            A dictionary where keys are module names and values are sets of symbols.
+
+        Returns
+        -------
+        str
+            Formatted import statements, one per line.
+        """
+        return "\n".join(
+            f"from {source} import {', '.join(sorted(var))}" if var else f"import {source}"
+            for source, var in imports.items()
+        )
+
+    def generate_boiler_plate_flask(self) -> str:
+        """
+        Builds the final AWS Lambda handler code as a complete Python string.
+
+        This includes import statements, any pre-construction logic, and
+        the `lambda_handler` function definition.
+
+        Returns
+        -------
+        str
+            The full source code of the handler as a string.
+        """
+        imports_chunk = self._generate_imports_string(self.importing)
+        sep = "\n" * 3
+        return f"{imports_chunk}{sep}{self.build or ''}{sep}{self.body or ''}\n"
+
+    def __add__(self, other: "StaticPythonConstructData") -> "StaticPythonConstructData":
+        """
+        Combine two AWSHandlerGenResponse objects by merging their fields.
+
+        Parameters
+        ----------
+        other : StaticPythonConstructData
+            Another response to merge.
+
+        Returns
+        -------
+        StaticPythonConstructData
+            A new instance with merged content.
+
+        Raises
+        ------
+        NotImplementedError
+            If `other` is not an instance of AWSHandlerGenResponse.
+        """
+        if not isinstance(other, StaticPythonConstructData):
+            raise NotImplementedError
+
+        merged_body = "\n".join(filter(None, [self.body, other.body])) or None
+        merged_build = "\n".join(filter(None, [self.build, other.build])) or None
+
+        merged_importing: Dict[str, Set[str]] = {}
+        for module in set(self.importing) | set(other.importing):
+            symbols_self = self.importing.get(module, set())
+            symbols_other = other.importing.get(module, set())
+            merged_importing[module] = symbols_self.union(symbols_other)
+
+        return StaticPythonConstructData(
+            body=merged_body,
+            build=merged_build,
+            importing=merged_importing,
+            extra={}
+        )
+
+    def __iadd__(self, other: "StaticPythonConstructData") -> "StaticPythonConstructData":
+        """
+        In-place addition of another AWSHandlerGenResponse instance.
+
+        Modifies the current instance by merging the fields from `other`.
+
+        Parameters
+        ----------
+        other : StaticPythonConstructData
+            The response to merge into this one.
+
+        Returns
+        -------
+        StaticPythonConstructData
+            The modified instance (`self`).
+
+        Raises
+        ------
+        NotImplementedError
+            If `other` is not an instance of AWSHandlerGenResponse.
+        """
+        if other is None:
+            return self
+        if not isinstance(other, StaticPythonConstructData):
+            raise NotImplementedError
+
+        self.body = "\n".join(filter(None, [self.body, other.body])) or None
+        self.build = "\n".join(filter(None, [self.build, other.build])) or None
+
+        for module, symbols in other.importing.items():
+            if module not in self.importing:
+                self.importing[module] = set()
+            self.importing[module].update(symbols)
+
+        self.extra = {}
+        return self

bisslog_flask/cli/__init__.py

@@ -0,0 +1,90 @@
+"""Command-line interface for the `bisslog_flask` package."""
+import argparse
+import os
+import sys
+import traceback
+
+from .commands.build import build_boiler_plate_flask
+from .commands.run import run
+
+
+def main():
+    """
+    Entry point for the `bisslog_flask` command-line interface.
+
+    This function parses command-line arguments and executes the corresponding
+    subcommand. Currently, it supports the `run` and `build` commands.
+
+    Commands
+    --------
+    run
+        Starts a Flask application based on provided metadata and use case folder.
+
+    build
+        Generates a Flask boilerplate app file from metadata and use cases.
+
+    Raises
+    ------
+    Exception
+        Any exception raised during command execution is caught and printed to stderr.
+    """
+    project_root = os.getcwd()
+
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+
+    parser = argparse.ArgumentParser(prog="bisslog_flask")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Define `run` command
+    run_parser = subparsers.add_parser("run", help="Run a Flask app using metadata.")
+    run_parser.add_argument("--metadata-file", type=str, default=None,
+                            help="Path to metadata file (YAML or JSON).")
+    run_parser.add_argument("--use-cases-folder-path", type=str, default=None,
+                            help="Path to use case source folder.")
+    run_parser.add_argument("--infra-path", type=str, default=None,
+                            help="Path to infrastructure code folder (optional).")
+    run_parser.add_argument("--encoding", type=str, default="utf-8",
+                            help="File encoding (default: utf-8).")
+    run_parser.add_argument("--secret-key", type=str,
+                            help="Flask SECRET_KEY config value.")
+    run_parser.add_argument("--jwt-secret-key", type=str,
+                            help="Flask JWT_SECRET_KEY config value.")
+
+    # Define `build` command
+    build_parser = subparsers.add_parser("build",
+                                         help="Generate a Flask app boilerplate file.")
+    build_parser.add_argument("--metadata-file", type=str, default=None,
+                              help="Path to metadata file (YAML or JSON).")
+    build_parser.add_argument("--use-cases-folder-path", type=str, default=None,
+                              help="Path to use case source folder.")
+    build_parser.add_argument("--infra-path", type=str, default=None,
+                              help="Path to infrastructure code folder (optional).")
+    build_parser.add_argument("--encoding", type=str, default="utf-8",
+                              help="File encoding (default: utf-8).")
+    build_parser.add_argument("--target-filename", type=str, default="flask_app.py",
+                              help="Filename to write the generated "
+                                   "boilerplate (default: flask_app.py)")
+
+    args = parser.parse_args()
+
+    try:
+        if args.command == "run":
+            run(metadata_file=args.metadata_file,
+                use_cases_folder_path=args.use_cases_folder_path,
+                infra_path=args.infra_path,
+                encoding=args.encoding,
+                secret_key=args.secret_key,
+                jwt_secret_key=args.jwt_secret_key)
+        elif args.command == "build":
+            build_boiler_plate_flask(
+                metadata_file=args.metadata_file,
+                use_cases_folder_path=args.use_cases_folder_path,
+                infra_path=args.infra_path,
+                encoding=args.encoding,
+                target_filename=args.target_filename
+            )
+    except Exception as e:  # pylint: disable=broad-except
+        traceback.print_exc()
+        print(e)
+        sys.exit(1)

bisslog_flask/cli/commands/build.py

@@ -0,0 +1,57 @@
+"""
+CLI-compatible utility for generating a Flask application boilerplate from Bisslog metadata.
+
+This module defines a function that reads service metadata and discovered use cases,
+generates the corresponding Flask application source code, and writes it to a file.
+It is intended to be used as part of a command-line interface or automation script
+to scaffold ready-to-run Flask services.
+
+The generated code supports HTTP and WebSocket routes, environment-based security
+configuration, and respects the Bisslog runtime setup defined via decorators.
+"""
+from typing import Optional
+
+from ...builder.builder_flask_app_manager import bisslog_flask_builder
+
+
+def build_boiler_plate_flask(
+        metadata_file: Optional[str] = None,
+        use_cases_folder_path: Optional[str] = None,
+        infra_path: Optional[str] = None,
+        encoding: str = "utf-8",
+        target_filename: str = "flask_app.py"
+):
+    """
+    Generates a Flask application boilerplate file from Bisslog metadata and use case code.
+
+    This function loads the service metadata and associated use cases, builds the Flask
+    application source code dynamically, and writes it to a Python file (e.g., `flask_app.py`).
+    The generated app includes route registration, security setup, and optional WebSocket support.
+
+    Parameters
+    ----------
+    metadata_file : str, optional
+        Path to the YAML or JSON metadata file describing the service.
+    use_cases_folder_path : str, optional
+        Path to the folder where the use case implementations are located.
+    infra_path : str, optional
+        Path to the folder where infrastructure components (e.g., adapters) are defined.
+    encoding : str, default="utf-8"
+        The file encoding to use when reading and writing files.
+    target_filename : str, default="flask_app.py"
+        The output filename where the Flask boilerplate code will be written.
+
+    Returns
+    -------
+    None
+        This function writes the generated Flask app code directly to the specified file.
+    """
+    flask_boiler_plate_string = bisslog_flask_builder(
+        metadata_file=metadata_file,
+        use_cases_folder_path=use_cases_folder_path,
+        infra_path=infra_path,
+        encoding=encoding
+    )
+
+    with open(target_filename, "w", encoding=encoding) as f:
+        f.write(flask_boiler_plate_string)

bisslog_flask/cli/commands/run.py

@@ -0,0 +1,52 @@
+"""
+Command module to run a Flask application using Bisslog metadata.
+
+This module provides a simple `run` function that initializes a Flask app
+with use case metadata and launches the server. It is intended to be used
+by the `bisslog_flask run` CLI command or directly from Python code.
+"""
+
+from typing import Optional
+
+from bisslog_flask import BisslogFlask
+
+
+def run(metadata_file: Optional[str] = None,
+        use_cases_folder_path: Optional[str] = None,
+        infra_path: Optional[str] = None,
+        encoding: str = "utf-8",
+        secret_key: Optional[str] = None,
+        jwt_secret_key: Optional[str] = None):
+    """
+    Run a Flask application using metadata and use-case source.
+
+    This function creates and runs a Flask app configured through the
+    BisslogFlask integration layer. It loads metadata definitions,
+    applies HTTP and WebSocket use case resolvers, and starts the server.
+
+    Parameters
+    ----------
+    metadata_file : str, optional
+        Path to the metadata file (YAML or JSON) containing service and trigger definitions.
+    use_cases_folder_path : str, optional
+        Path to the folder where the use case implementation code is located.
+    infra_path : str, optional
+        Path to the folder containing infrastructure code (e.g., database, cache).
+        This is not used in the current implementation but can be extended.
+    encoding : str, optional
+        Encoding used to read the metadata file (default is "utf-8").
+    secret_key : str, optional
+        Value to set as Flask's SECRET_KEY for session signing.
+    jwt_secret_key : str, optional
+        Value to set as Flask's JWT_SECRET_KEY for JWT-based authentication.
+    """
+    app = BisslogFlask(
+        metadata_file=metadata_file,
+        use_cases_folder_path=use_cases_folder_path,
+        infra_path=infra_path,
+        encoding=encoding,
+        secret_key=secret_key,
+        jwt_secret_key=jwt_secret_key
+    )
+
+    app.run()

bisslog_flask/initializer/bisslog_flask_http_resolver.py

@@ -16,10 +16,12 @@ Dependencies
 - bisslog_schema
 - bisslog.utils.mapping
 """
+import inspect
 from copy import deepcopy
-from typing import Callable, Optional, Dict
+from typing import Callable, Optional, Dict, Union, Awaitable, Any
 
 from flask import Flask, request, jsonify
+
 try:
     from flask_cors import cross_origin
 except ImportError:
@@ -82,10 +84,10 @@ class BisslogFlaskHttpResolver(BisslogFlaskResolver):
 
     @staticmethod
     def _use_case_factory(
-            use_case_name: str,
-            fn: Callable,
-            mapper: Optional[Dict[str, str]] = None,
-            trigger: Optional[TriggerHttp] = None
+        use_case_name: str,
+        fn: Callable,
+        mapper: Optional[Dict[str, str]] = None,
+        trigger: Optional[TriggerHttp] = None
     ):
         """
         Factory to produce a Flask view function with optional mapping and CORS.
@@ -109,10 +111,49 @@ class BisslogFlaskHttpResolver(BisslogFlaskResolver):
         use_case_fn_copy = deepcopy(fn)
         __mapper__ = Mapper(name=f"Mapper {use_case_name}", base=mapper) if mapper else None
 
-        def uc(*args, **kwargs):
-            return BisslogFlaskHttpResolver._lambda_fn(
-                *args, fn=use_case_fn_copy, __mapper__=__mapper__, **kwargs
-            )
+        is_async = (
+            inspect.iscoroutinefunction(fn)
+            or inspect.iscoroutinefunction(getattr(fn, "__call__", None))
+        )
+
+        if is_async:
+            async def uc(*args, **kwargs):
+                if __mapper__ is None:
+                    more_kwargs = {}
+                    if request.method.lower() != "get":
+                        more_kwargs.update(request.get_json(silent=True) or {})
+                    res = await use_case_fn_copy(*args, **kwargs, **more_kwargs)
+                    return jsonify(res)
+
+                res_map = __mapper__.map({
+                    "path_query": request.view_args or {},
+                    "body": request.get_json(silent=True) or {},
+                    "params": request.args.to_dict(),
+                    "headers": request.headers,
+                })
+                res = await use_case_fn_copy(**res_map)
+                return jsonify(res)
+
+            view = uc
+        else:
+            def uc(*args, **kwargs):
+                if __mapper__ is None:
+                    more_kwargs = {}
+                    if request.method.lower() != "get":
+                        more_kwargs.update(request.get_json(silent=True) or {})
+                    res = use_case_fn_copy(*args, **kwargs, **more_kwargs)
+                    return jsonify(res)
+
+                res_map = __mapper__.map({
+                    "path_query": request.view_args or {},
+                    "body": request.get_json(silent=True) or {},
+                    "params": request.args.to_dict(),
+                    "headers": request.headers,
+                })
+                res = use_case_fn_copy(**res_map)
+                return jsonify(res)
+
+            view = uc
 
         # Apply CORS dynamically if allowed
         if trigger and trigger.allow_cors:
@@ -124,13 +165,13 @@ class BisslogFlaskHttpResolver(BisslogFlaskResolver):
                 "allow_headers": ["Content-Type", "Authorization"],
                 "supports_credentials": True
             }
-            return cross_origin(**cors_kwargs)(uc)
+            return cross_origin(**cors_kwargs)(view)
 
-        return uc
+        return view
 
     @classmethod
     def _add_use_case(cls, app: Flask, use_case_info: UseCaseInfo, trigger: TriggerInfo,
-                      use_case_function):
+                      use_case_function: Union[Callable[..., Any], Callable[..., Awaitable[Any]]]):
         """
         Adds an HTTP endpoint to the Flask app for a given use case.
 

bisslog_flask/initializer/bisslog_flask_resolver.py

@@ -9,7 +9,6 @@ from abc import ABC, abstractmethod
 from typing import Callable
 
 from bisslog_schema.schema import UseCaseInfo, TriggerInfo
-
 from flask import Flask
 
 

bisslog_flask/initializer/bisslog_flask_ws_resolver.py

@@ -5,7 +5,9 @@ This module defines the `BisslogFlaskWebSocketResolver` class, which dynamically
 WebSocket-based use case triggers in a Flask app. The class uses metadata definitions to
 configure event routes (via `route_key`) and binds them to corresponding use case functions.
 """
+import inspect
 from typing import Callable
+
 from flask import Flask, request
 
 try:
@@ -64,13 +66,27 @@ class BisslogFlaskWebSocketResolver(BisslogFlaskResolver):
             base=trigger_info.options.mapper
         ) if trigger_info.options.mapper else None
 
-        @socket_io_obj.on(route_key)
-        def on_event(data):
-            mapped_data = mapper.map({
-                "route_key": route_key,
-                "connection_id": request.sid,
-                "body": data,
-                "headers": dict(request.headers)
-            }) if mapper else data
+        is_async = inspect.iscoroutinefunction(use_case_callable)
+
+        if is_async:
+            @socket_io_obj.on(route_key)
+            async def on_event(data):
+                mapped_data = mapper.map({
+                    "route_key": route_key,
+                    "connection_id": request.sid,
+                    "body": data,
+                    "headers": dict(request.headers)
+                }) if mapper else data
+
+                return await use_case_callable(**mapped_data) if mapper else use_case_callable(data)
+        else:
+            @socket_io_obj.on(route_key)
+            def on_event(data):
+                mapped_data = mapper.map({
+                    "route_key": route_key,
+                    "connection_id": request.sid,
+                    "body": data,
+                    "headers": dict(request.headers)
+                }) if mapper else data
 
-            return use_case_callable(**mapped_data) if mapper else use_case_callable(data)
+                return use_case_callable(**mapped_data) if mapper else use_case_callable(data)

bisslog_flask/initializer/init_flask_app_manager.py

@@ -18,7 +18,9 @@ Dependencies
 from typing import Optional, Callable
 
 from bisslog_schema import read_service_info_with_code
+from bisslog_schema.eager_import_module_or_package import EagerImportModulePackage
 from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerWebsocket
+from bisslog_schema.setup import run_setup
 from flask import Flask
 
 from .bisslog_flask_http_resolver import BisslogFlaskHttpResolver
@@ -42,14 +44,17 @@ class InitFlaskAppManager:
     """
 
     def __init__(self, http_processor: BisslogFlaskResolver,
-                 websocket_processor: BisslogFlaskResolver) -> None:
+                 websocket_processor: BisslogFlaskResolver,
+                 force_import: Callable[[str], None]) -> None:
         self._http_processor = http_processor
         self._websocket_processor = websocket_processor
+        self._force_import = force_import
 
     def __call__(
             self,
             metadata_file: Optional[str] = None,
             use_cases_folder_path: Optional[str] = None,
+            infra_path: Optional[str] = None,
             app: Optional[Flask] = None,
             *,
             encoding: str = "utf-8",
@@ -69,6 +74,9 @@ class InitFlaskAppManager:
             Path to the metadata file (YAML/JSON).
         use_cases_folder_path : str, optional
             Directory where use case code is located.
+        infra_path : str, optional
+            Path to the folder where infrastructure components (e.g., adapters) are defined.
+            This is used to ensure that necessary modules are imported before route registration.
         app : Flask, optional
             An existing Flask app instance to which routes will be added.
             If not provided, a new app is created using the service name.
@@ -94,6 +102,11 @@ class InitFlaskAppManager:
         service_info = full_service_data.declared_metadata
         use_cases = full_service_data.discovered_use_cases
 
+        # Force import
+        self._force_import(infra_path)
+        # Run global setup if defined
+        run_setup("flask")
+
         # Initialize Flask app
         if app is None:
             app = Flask(service_info.name)
@@ -120,4 +133,5 @@ class InitFlaskAppManager:
         return app
 
 
-BisslogFlask = InitFlaskAppManager(BisslogFlaskHttpResolver(), BisslogFlaskWebSocketResolver())
+BisslogFlask = InitFlaskAppManager(BisslogFlaskHttpResolver(), BisslogFlaskWebSocketResolver(),
+                                   EagerImportModulePackage(("src.infra", "infra")))

bisslog_flask/socket_helper/socket_helper.py

@@ -20,9 +20,6 @@ class BisslogFlaskSocketHelper(WebSocketManager):
     a consistent interface.
     """
 
-    def __init__(self, conn) -> None:
-        super().__init__(conn)
-
     def emit(self, event: str, connection_id: str, payload: Any,
              broadcast: bool = False, to: str = None):
         """

{bisslog_flask-0.0.1.dist-info → bisslog_flask-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bisslog_flask
-Version: 0.0.1
+Version: 0.0.3
 Summary: It is an extension of the bisslog library to support processes with flask
 Author-email: Darwin Stiven Herrera Cartagena <darwinsherrerac@gmail.com>
 Project-URL: Homepage, https://github.com/darwinhc/bisslog-flask
@@ -10,54 +10,54 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: bisslog>=0.0.7
-Requires-Dist: bisslog-schema>=0.0.3
+Requires-Dist: bisslog>=0.0.9
+Requires-Dist: bisslog-schema>=0.0.10
 Requires-Dist: flask
 Provides-Extra: websocket
 Requires-Dist: flask-socketio; extra == "websocket"
 Provides-Extra: cors
 Requires-Dist: flask-cors>=6.0.0; extra == "cors"
+Provides-Extra: async
+Requires-Dist: Flask[async]>=2.2; extra == "async"
 Dynamic: license-file
 
-
 # bisslog-flask
 
 [![PyPI](https://img.shields.io/pypi/v/bisslog-flask)](https://pypi.org/project/bisslog-flask/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-**bisslog-flask** is an extension of the bisslog library to support processes with Flask. It enables dynamic HTTP and WebSocket route registration from use case metadata, allowing developers to build clean, modular, and metadata-driven APIs with minimal boilerplate.
+**bisslog-flask** is an extension of the Bisslog library to support processes with Flask.  
+It enables dynamic HTTP and WebSocket route registration from use case metadata, allowing developers to build clean, modular, and metadata-driven APIs with minimal boilerplate.
 
-Part of the bisslog ecosystem, it is designed to work seamlessly with domain-centric architectures like Hexagonal or Clean Architecture.
+Part of the Bisslog ecosystem, it is designed to work seamlessly with domain-centric architectures like Hexagonal or Clean Architecture.
 
-## Features
+---
 
-- 🔁 Dynamic route registration for HTTP and WebSocket triggers
+## ✨ Features
 
+- 🔁 Dynamic route registration for HTTP and WebSocket triggers
 - 🧠 Metadata-driven setup – use YAML or JSON to declare your use cases
-
-- 🔒 Automatic CORS per endpoint using flask-cors
-
+- 🔒 Automatic CORS per endpoint using `flask-cors`
 - 🔌 Extensible resolver pattern – plug in your own processor
-
 - ⚙️ Mapper integration – maps HTTP request parts to domain function arguments
 
-
+---
 
 ## 📦 Installation
 
-~~~shell
+```bash
 pip install bisslog-flask
-~~~
-
-
+```
 
+---
 
 ## 🚀 Quickstart
 
 ### Programmatically
 
-if you want to configure the app before bisslog touches it
-~~~python
+Use this approach if you want to configure the app before Bisslog touches it:
+
+```python
 from flask import Flask
 from bisslog_flask import BisslogFlask
 
@@ -70,11 +70,11 @@ BisslogFlask(
 
 if __name__ == "__main__":
     app.run(debug=True)
-~~~
+```
 
-or
+Or use the factory version:
 
-~~~python
+```python
 from bisslog_flask import BisslogFlask
 
 app = BisslogFlask(
@@ -84,58 +84,73 @@ app = BisslogFlask(
 
 if __name__ == "__main__":
     app.run(debug=True)
-~~~
-
+```
 
+---
 
-## 🔧 How It Works
+## 🖥️ CLI Usage
 
-1. Loads metadata and discovers use case functions (or callables), then uses resolvers to register routes dynamically into a Flask app.
+You can also use the `bisslog_flask` CLI to run or generate a Flask app.
 
+```bash
+bisslog_flask run [--metadata-file FILE] [--use-cases-folder-path DIR]
+                  [--infra-folder-path DIR] [--encoding ENC]
+                  [--secret-key KEY] [--jwt-secret-key KEY]
 
-## 🔐 CORS Handling
+bisslog_flask build [--metadata-file FILE] [--use-cases-folder-path DIR]
+                    [--infra-folder-path DIR] [--encoding ENC]
+                    [--target-filename FILE]
+```
 
-CORS is applied only when allow_cors: true is specified in the trigger
+- `run`: Launches the Flask application from metadata.
+- `build`: Generates a boilerplate Flask file (`flask_app.py` by default).
 
-Fully dynamic: works even with dynamic Flask routes like /users/<id>
+All options are optional. You can override defaults via CLI flags.
 
-Powered by `@cross_origin` from `flask-cors`
+---
 
+## 🔐 CORS Handling
 
-## ✅ Requirements
+CORS is applied only when `allow_cors: true` is specified in the trigger.
 
-Python ≥ 3.7
+Fully dynamic: works even with Flask dynamic routes like `/users/<id>`.
 
-Flask ≥ 2.0
+Powered by `@cross_origin` from `flask-cors`.
 
-bisslog-schema ≥ 0.0.3
+---
 
-flask-cors
+## ✅ Requirements
 
-(Optional) flask-socketio if using WebSocket triggers
+- Python ≥ 3.7
+- Flask ≥ 2.0
+- bisslog-schema ≥ 0.0.3
+- flask-cors
+- (Optional) flask-sock if using WebSocket triggers
 
+---
 
 ## 🧪 Testing Tip
 
-You can test the generated Flask app directly with `app.test_client()` if you take the programmatic way:
+You can test the generated Flask app directly with `app.test_client()` if using the programmatic interface:
 
 ```python
 from bisslog_flask import BisslogFlask
 
 def test_user_create():
-    app = BisslogFlask(metadata_file="metadata.yml", use_cases_folder_path="src/use_cases")
+    app = BisslogFlask(
+        metadata_file="metadata.yml",
+        use_cases_folder_path="src/use_cases"
+    )
     client = app.test_client()
     response = client.post("/user", json={"name": "Ana", "email": "ana@example.com"})
     assert response.status_code == 200
 ```
 
-Not generating code or using the programmatic way you just need to test your use cases.
-
+If you're generating the code (boilerplate), you just need to test your use cases.
 
+---
 
 ## 📜 License
 
-This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
-
-
-
+This project is licensed under the MIT License.  
+See the [LICENSE](LICENSE) file for details.

bisslog_flask-0.0.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+bisslog_flask/__init__.py,sha256=BEf_UxFtcMfaM-Smh_bwc6Xn8pR8LcEjby3nCs0hdXE,758
+bisslog_flask/builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisslog_flask/builder/builder_flask_app_manager.py,sha256=HffxWfMRRlrfmYSojCdH563bJgQGa3vF2GB9rOYnINw,14777
+bisslog_flask/builder/static_python_construct_data.py,sha256=p8QcXUAXZRXtNlghWv-husw9hByGTp53_g0RxhmzoNc,5735
+bisslog_flask/cli/__init__.py,sha256=DlqqUfYI3e3Q6wY7xg7X-Ux9_6gTNQAAClAe2aI2-tg,3792
+bisslog_flask/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisslog_flask/cli/commands/build.py,sha256=uI-aH8HvW7UPdqGJvtQ2p5tw5nEFcUAzvicLCGuKccY,2341
+bisslog_flask/cli/commands/run.py,sha256=gUfgpLzPxQ-hB2DApA-BcxpkPaI_QCNH7OUUpkl8D34,1953
+bisslog_flask/initializer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisslog_flask/initializer/bisslog_flask_http_resolver.py,sha256=nxAZFyl_7akpMzgDQsURVAbJmTxuFKlpCu3SfYioh44,7890
+bisslog_flask/initializer/bisslog_flask_resolver.py,sha256=pt7EC-WqfsBp7w3Z0SE378hfwWTLfRDM6fGMfF3_sb8,1707
+bisslog_flask/initializer/bisslog_flask_ws_resolver.py,sha256=wcG8iPky2PYyRUovHJg5woX1vLJ-fmLRmgUW-PLU_Jc,3572
+bisslog_flask/initializer/init_flask_app_manager.py,sha256=gwu6cg6RLh5UMT4GGiIFJx8cD385j7EvUnGfk9S6aC0,5389
+bisslog_flask/socket_helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bisslog_flask/socket_helper/socket_helper.py,sha256=HHENwYT-qdrJlwmGszYqFM1MA1g6naRurUp6sYCHRRQ,2967
+bisslog_flask-0.0.3.dist-info/licenses/LICENSE,sha256=TSlM1hRIXc6yR3xpGzy2DMSSbds0svqHSetfNfQqCEk,1074
+bisslog_flask-0.0.3.dist-info/METADATA,sha256=8X8f3Lsko5s7NX8iZwkP1gFpVNoOdRVUSjKinqaaVyk,4251
+bisslog_flask-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bisslog_flask-0.0.3.dist-info/entry_points.txt,sha256=A2_A5lZt973oUBpuOCC78aTm7dGyHk6cemnn5_jOXHw,57
+bisslog_flask-0.0.3.dist-info/top_level.txt,sha256=Xk85d0SIhkUP1HjsXOtq2vlU7yQT3mFApyb5IVgtG6w,14
+bisslog_flask-0.0.3.dist-info/RECORD,,

bisslog_flask-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bisslog_flask = bisslog_flask.cli:main

bisslog_flask-0.0.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-bisslog_flask/__init__.py,sha256=BEf_UxFtcMfaM-Smh_bwc6Xn8pR8LcEjby3nCs0hdXE,758
-bisslog_flask/initializer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bisslog_flask/initializer/bisslog_flask_http_resolver.py,sha256=d-KFQwMXeRyq3_Cu5bxCF7CpnetfnKainChEbdxDk2c,6257
-bisslog_flask/initializer/bisslog_flask_resolver.py,sha256=QWjft6HZbBplbP1vVMNoPhGoSZBJubAotwLR76HVttw,1708
-bisslog_flask/initializer/bisslog_flask_ws_resolver.py,sha256=s-eDdk5HA6E_D8iZC6IN7RSW-96mzu8m8VGL3Xqm9PQ,2974
-bisslog_flask/initializer/init_flask_app_manager.py,sha256=QzO1dae3YFap2VEXK3gSexLkdfBGaLWrHK732z5s0K0,4682
-bisslog_flask/socket_helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bisslog_flask/socket_helper/socket_helper.py,sha256=sR9xQSPWzijhPNRh8WRxDbzE7rqFqm4w0Vql4gBGiGU,3037
-bisslog_flask-0.0.1.dist-info/licenses/LICENSE,sha256=TSlM1hRIXc6yR3xpGzy2DMSSbds0svqHSetfNfQqCEk,1074
-bisslog_flask-0.0.1.dist-info/METADATA,sha256=w82no5oSrRtS7XEDT38gs6UYIrzyuBHK4eEJkpQptH0,3551
-bisslog_flask-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bisslog_flask-0.0.1.dist-info/top_level.txt,sha256=Xk85d0SIhkUP1HjsXOtq2vlU7yQT3mFApyb5IVgtG6w,14
-bisslog_flask-0.0.1.dist-info/RECORD,,