spa-cli 1.0.0__py3-none-any.whl

spa_cli/__main__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+app(prog_name='spa-src')

spa_cli/cli.py

@@ -0,0 +1,26 @@
+from importlib.metadata import version as v
+
+import typer
+from dotenv import load_dotenv
+
+from .src.project import project
+from .src.model import model
+from .src.endpoint import endpoint
+from .src.lambda_function import lambda_function
+
+load_dotenv()
+
+app = typer.Typer()
+app.add_typer(project.app, name='project')
+# app.add_typer(model.app, name='model')
+app.add_typer(endpoint.app, name='endpoint')
+app.add_typer(lambda_function.app, name='lambda')
+
+
+@app.callback(invoke_without_command=True)
+def callback_version(version: bool = False):
+    """
+    Imprime la versión del CLI.
+    """
+    if version:
+        typer.echo(f'version: {v("spa-cli")}')

spa_cli/globals.py

@@ -0,0 +1,215 @@
+from enum import Enum
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TypeVar, Type, cast, Callable, List
+import typer
+import toml
+import datetime
+from dotenv import load_dotenv
+
+class Constants(Enum):
+    PROJECT_TEMPLATE = "https://github.com/DavidCuy/serverless-python-application-pattern.git"
+    MYSQL_ENGINE = "mysql"
+    POSTGRESQL_ENGINE = "postgresql"
+    
+    AWS_REPOSITORY = "aws"
+    OTHER_REPOSITORY = "other"
+    
+    LOCALHOST_DB_DOCKER = "host.docker.internal"
+    MSSQL_SA_USER = "sa"
+
+    VALID_MODEL_TYPES = (int, str, float, datetime.datetime)
+    JSON_INT_DTYPE = 'int'
+    JSON_FLOAT_DTYPE = 'float'
+    JSON_STRING_DTYPE = 'str'
+    JSON_DATETIME_DTYPE = 'datetime'
+
+DRIVERS = {
+    Constants.MYSQL_ENGINE.value: "pymysql",
+    Constants.POSTGRESQL_ENGINE.value: "psycopg2"
+}
+
+def get_driver_from_engine(engine: Constants):
+    return DRIVERS.get(engine.value, None)
+
+SQL_PORTS_DEFAULT = {
+    Constants.MYSQL_ENGINE.value: "3306",
+    Constants.POSTGRESQL_ENGINE.value: "5432"
+}
+
+JSON_MAPPING_VALUE = {
+    Constants.JSON_INT_DTYPE.value: 'Column("{ColumnName}", Integer)',
+    Constants.JSON_STRING_DTYPE.value: 'Column("{ColumnName}", String)',
+    Constants.JSON_FLOAT_DTYPE.value: 'Column("{ColumnName}", Float)',
+    Constants.JSON_DATETIME_DTYPE.value: 'Column("{ColumnName}", DateTime)'
+}
+
+T = TypeVar("T")
+
+def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
+    assert isinstance(x, list)
+    return [f(y) for y in x]
+
+
+def from_str(x: Any) -> str:
+    assert isinstance(x, str)
+    return x
+
+
+def from_str_to_list(x: Any) -> List[str]:
+    assert isinstance(x, str)
+    return [x]
+
+
+def from_union(fs, x):
+    for f in fs:
+        try:
+            return f(x)
+        except:
+            pass
+    assert False
+
+
+def to_class(c: Type[T], x: Any) -> dict:
+    assert isinstance(x, c)
+    return cast(Any, x).to_dict()
+
+class BaseConf:
+    @property
+    def attrs(self) -> List[str]:
+        """ Returns a list of the attributes of an object
+        Returns:
+            List[str]: Attributes
+        """
+        return list(filter(lambda prop: not str(prop).startswith('_'), self.__dict__.keys()))
+    
+    @classmethod
+    def from_dict(cls_, obj: Any) -> 'Folders':
+        assert isinstance(obj, dict)
+        
+        obj_dict = {}
+        attributes = list(filter(lambda prop: not str(prop).startswith('_'), (cls_).__dataclass_fields__.keys()))
+        for attr in attributes:
+            obj_dict.update({attr: from_str(obj.get(attr))})
+        return cls_(**obj_dict)
+    
+    def to_dict(self):
+        output_dict = {}
+        for attr in self.attrs:
+            output_dict.update({attr: self.__getattribute__(attr)})
+        return output_dict
+    
+    def __repr__(self) -> str:
+        """ Model representation
+        Returns:
+            str: Model output string formatted
+        """
+        attr_array = [f"{attr}={self.__getattribute__(attr)}" for attr in self.attrs]
+        args_format = ",".join(attr_array)
+        return f"<{type(self).__name__}({args_format})>"
+
+@dataclass
+class Files(BaseConf):
+    model: str
+    service: str
+    controller: str
+    endpoint: str
+    lambda_function: str
+    test_lambda: str
+    lambda_conf: str
+
+
+@dataclass
+class Folders(BaseConf):
+    models: str
+    services: str
+    controllers: str
+    lambdas: str
+    root: str
+    jsons: str
+    layers: str
+
+@dataclass
+class Definition(BaseConf):
+    name: str
+    description: str
+    author: str
+    author_email: str
+    base_api: str
+
+@dataclass
+class Project(BaseConf):
+    definition: Definition
+    folders: Folders
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Project':
+        assert isinstance(obj, dict)
+        definition = Definition.from_dict(obj.get("definition"))
+        folders = Folders.from_dict(obj.get("folders"))
+        return Project(definition, folders)
+
+@dataclass
+class Template(BaseConf):
+    files: Files
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Template':
+        assert isinstance(obj, dict)
+        files = Files.from_dict(obj.get("files"))
+        return Template(files)
+
+@dataclass
+class Config(BaseConf):
+    project: Project
+    template: Template
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Config':
+        assert isinstance(obj, dict)
+        project = Project.from_dict(obj.get("project"))
+        template = Template.from_dict(obj.get("template"))
+        return Config(project, template)
+
+
+def load_config(path="spa_project.toml") -> Config:
+    config_path = Path(Path.cwd() / path)
+    if not config_path.exists():
+        typer.echo("config file not found in the project.", color=typer.colors.YELLOW)
+        load_dotenv(".env")
+        app_name = os.getenv("app_name") or ""
+        config_path.write_text(f"""[spa.project.definition]
+name = "{app_name}"
+description = ""
+author = "David Cuy"
+author_email = ""
+base_api = "api.yaml"
+
+[spa.template.files]
+model = ".spa/templates/models/model.txt"
+service = ".spa/templates/models/service.txt"
+controller = ".spa/templates/models/controller.txt"
+endpoint = ".spa/templates/lambda_endpoint.txt"
+lambda_function = ".spa/templates/lambda.txt"
+test_lambda = ".spa/templates/test_lambda_function.txt"
+lambda_conf = ".spa/templates/lambda_conf.txt"
+
+[spa.project.folders]
+root = "src"
+models = "src/layers/databases/python/core_db/models"
+services = "src/layers/databases/python/core_db/services"
+controllers = "src/layers/core/python/core_http/controllers"
+jsons = ".spa/templates/json"
+lambdas = "src/lambdas"
+layers = "src/layers"
+        """)
+        typer.echo(
+            f"Created config file at {config_path} in this path you can find all configuration for the project here.")
+        typer.echo(f"Please add the file {config_path} to git tracking and commit it")
+    try:
+        toml_config = toml.loads(config_path.read_text())
+    except Exception as e:
+        typer.echo("Error reading the config file, please check the file format.", color=typer.colors.RED)
+        raise 
+    return Config.from_dict(toml_config["spa"])

spa_cli/src/endpoint/endpoint.py

@@ -0,0 +1,75 @@
+from ...globals import load_config
+from ..utils.folders import validate_path_not_exist
+from ..utils.strings import camel_case
+from ..utils.template_gen import copy_template_file
+
+import os
+import typer
+from pathlib import Path
+
+app = typer.Typer()
+
+@app.command('add')
+def new_endpoint(
+        method: str = typer.Option(..., help='Metodo de la peticion. Valores permitidos [GET, POST, PUT, PATCH, DELETE]'),
+        path: str = typer.Option(..., help='Path del endpoint.'),
+        endpoint_name: str = typer.Option(help='Nombre de la funcion lambda.')
+    ):
+    
+    if "-" in endpoint_name or " " in endpoint_name:
+        typer.echo('El nombre de la lambda no debe contener espacios o guiones. Se modificará por guiones bajos.', color=typer.colors.YELLOW)
+        endpoint_name = endpoint_name.replace("-", "_").replace(" ", "_")
+    
+    config = load_config()
+    camel_name = camel_case(endpoint_name)
+    
+    lambda_template_path = Path(config.template.files.lambda_function)
+    lambda_test_template_path = Path(config.template.files.test_lambda)
+    lambda_conf_template_path = Path(config.template.files.lambda_conf)
+    lambda_endpoint_template_path = Path(config.template.files.endpoint)
+    
+    lambda_output_folder_path = Path(config.project.folders.lambdas)
+
+    try:
+        model_exists = validate_path_not_exist(path=lambda_output_folder_path.joinpath(endpoint_name), custom_error_message=f'Ya existe una ruta con nombre: {endpoint_name}', abort=False)
+    except Exception as e:
+        typer.echo(str(e))
+    
+    if not model_exists:
+        os.mkdir(lambda_output_folder_path.joinpath(endpoint_name))
+    
+    copy_template_file(
+        template_path=lambda_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('lambda_function.py'),
+        code_format_override={}
+    )
+    
+    copy_template_file(
+        template_path=lambda_test_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('test_lambda_function.py'),
+        code_format_override={
+            "camel_name": camel_name,
+            "lambda_name": endpoint_name
+        }
+    )
+    
+    copy_template_file(
+        template_path=lambda_conf_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('infra_config.py'),
+        code_format_override={
+            "lambda_name": endpoint_name,
+            "camel_name": camel_name
+        }
+    )
+    
+    copy_template_file(
+        template_path=lambda_endpoint_template_path,
+        destination_path=lambda_output_folder_path.joinpath(endpoint_name).joinpath('endpoint.yaml'),
+        code_format_override={
+            "endpoint_url": path,
+            "endpoint_method": method.lower(),
+        }
+    )
+
+    typer.echo(f'La ruta {path} [{method}] se agrego correctamente!', color=typer.colors.GREEN)
+

spa_cli/src/lambda_function/lambda_function.py

@@ -0,0 +1,62 @@
+from ...globals import load_config
+from ..utils.folders import validate_path_not_exist
+from ..utils.strings import camel_case
+from ..utils.template_gen import copy_template_file
+
+import os
+import typer
+from pathlib import Path
+
+app = typer.Typer()
+
+@app.command('add')
+def new_lambda(
+        lambda_name: str = typer.Option(help='Nombre de la funcion lambda.')
+    ):
+    config = load_config()
+    
+    if "-" in lambda_name or " " in lambda_name:
+        typer.echo('El nombre de la lambda no debe contener espacios o guiones. Se modificará por guiones bajos.', color=typer.colors.YELLOW)
+        lambda_name = lambda_name.replace("-", "_").replace(" ", "_")
+    camel_name = camel_case(lambda_name)
+    
+    lambda_template_path = Path(config.template.files.lambda_function)
+    lambda_test_template_path = Path(config.template.files.test_lambda)
+    lambda_conf_template_path = Path(config.template.files.lambda_conf)
+    
+    lambda_output_folder_path = Path(config.project.folders.lambdas)
+
+    try:
+        model_exists = validate_path_not_exist(path=lambda_output_folder_path.joinpath(lambda_name), custom_error_message=f'Ya existe una ruta con nombre: {lambda_name}', abort=False)
+    except Exception as e:
+        typer.echo(str(e))
+    
+    if not model_exists:
+        os.mkdir(lambda_output_folder_path.joinpath(lambda_name))
+    
+    copy_template_file(
+        template_path=lambda_template_path,
+        destination_path=lambda_output_folder_path.joinpath(lambda_name).joinpath('lambda_function.py'),
+        code_format_override={}
+    )
+    
+    copy_template_file(
+        template_path=lambda_test_template_path,
+        destination_path=lambda_output_folder_path.joinpath(lambda_name).joinpath('test_lambda_function.py'),
+        code_format_override={
+            "camel_name": camel_name,
+            "lambda_name": lambda_name
+        }
+    )
+    
+    copy_template_file(
+        template_path=lambda_conf_template_path,
+        destination_path=lambda_output_folder_path.joinpath(lambda_name).joinpath('infra_config.py'),
+        code_format_override={
+            "lambda_name": lambda_name,
+            "camel_name": camel_name
+        }
+    )
+
+    typer.echo(f'La lambda {lambda_name} se agrego correctamente!', color=typer.colors.GREEN)
+

spa_cli/src/model/model.py

@@ -0,0 +1,140 @@
+from ...globals import load_config, Config, Constants, JSON_MAPPING_VALUE
+from ..utils.folders import validate_path_not_exist, validate_path_exist
+from ..utils.strings import camel_case, snake_case
+from ..utils.template_gen import add_code_to_module, add_file_to_module, read_project_config
+
+import json
+import typer
+from typing import cast
+from pathlib import Path
+from dateutil import parser
+from typing_extensions import Annotated
+
+app = typer.Typer()
+
+@app.command('new')
+def new_model(name: str = typer.Option(..., help='Nombre del nuevo modelo.'), tablename: str = typer.Option(help='Nombre de la tabla', default='same-model-name')):
+    config = load_config()
+    name = camel_case(name)
+    tablename = camel_case(name if tablename == 'same-model-name' else tablename)
+    models_folder_path = Path(config.project.folders.models)
+
+    validate_path_not_exist(path=models_folder_path.joinpath(f'{name}.py'), custom_error_message=f'Ya existe un modelo con nombre: {name}')
+    __generate_full_model_config(config, name, tablename)
+
+    typer.echo(f'{name} se agrego correctamente!', color=typer.colors.GREEN)
+
+
+
+@app.command('fromJson')
+def new_from_json(
+        name: str = typer.Option(..., help='Nombre del archivo JSON a leer. Sin extension'),
+        tablename: str = typer.Option(help='Nombre de la tabla', default='same-model-name')
+    ):
+    """
+    Crea un nuevo modelo de acuerdo con el nombre especificado y el archivo en la ruta "./.spa/templates/json"
+    """
+    config = load_config()
+    try:
+        project_config = read_project_config()
+    except:
+        typer.echo('No se puedo leer la configuracion del proyecto', color=typer.colors.RED)
+        raise typer.Abort()
+    name = camel_case(name)
+    tablename = camel_case(name if tablename == 'same-model-name' else tablename)
+    json_folder_path = Path(config.project.folders.jsons)
+    validate_path_exist(path=json_folder_path.joinpath(f'{name.lower()}.json'), custom_error_message=f'No se pudo encontrar el archivo {name.lower()}.json')
+
+    try:
+        model_map = cast(dict, json.loads(json_folder_path.joinpath(f'{name.lower()}.json').read_text()))
+    except Exception as e:
+        typer.echo('No se pudo leer el json correctamente', typer.colors.RED)
+        typer.Abort()
+
+    __generate_full_model_config(config, name, tablename)
+
+    full_column_text = ''
+    full_propmap_text = ''
+    full_display_member = ''
+    for key in model_map.keys():
+        if isinstance(model_map[key], Constants.VALID_MODEL_TYPES.value):
+            key_type = type(model_map[key]).__name__
+
+            if key_type == Constants.JSON_STRING_DTYPE.value:
+                try:
+                    is_date = bool(parser.parse(model_map[key]))
+                    if is_date:
+                        key_type = Constants.JSON_DATETIME_DTYPE.value
+                except ValueError:
+                    # 'String is not datetime format'
+                    pass
+
+            data_column_line_text = f"""
+    {key} = {JSON_MAPPING_VALUE[key_type].format(**{'ColumnName': camel_case(key)})}"""
+            #here replace
+            if key_type == Constants.JSON_STRING_DTYPE.value:
+                if project_config['dbDialect'] == Constants.MYSQL_ENGINE.value:
+                    data_column_line_text = data_column_line_text.replace('String', 'String(512)')
+            full_column_text += data_column_line_text
+            full_propmap_text += f""",
+            "{key}": "{camel_case(key)}\""""
+            full_display_member += f""",
+            "{key}\""""
+    
+    models_folder_path = Path(config.project.folders.models)
+    model_text = models_folder_path.joinpath(f'{name}.py').read_text()
+    search_text_id = f'id = Column("Id{name}", Integer, primary_key=True)'
+    search_text_propmap = f"""def property_map(self) -> Dict:
+        return """ + '{' + f"""
+            "id": "Id{name}\""""
+    search_text_display = """def display_members(cls_) -> List[str]:
+        return [
+            "id\""""
+
+    search_id = model_text.index(search_text_id) + len(search_text_id)
+    search_propmap = model_text.index(search_text_propmap) + len(search_text_propmap)
+    search_display = model_text.index(search_text_display) + len(search_text_display)
+    
+    model_text = model_text[:search_id] \
+            + full_column_text \
+            + model_text[search_id:search_propmap] \
+            + full_propmap_text \
+            + model_text[search_propmap:search_display] \
+            + full_display_member \
+            + model_text[search_display:]
+    models_folder_path.joinpath(f'{name}.py').write_text(model_text)
+
+
+    typer.echo(f'{name} se agrego correctamente!', color=typer.colors.GREEN)
+
+def __generate_full_model_config(config: Config, name: str, tablename: str):
+    models_folder_path = Path(config.project.folders.models)
+    template_model_path = Path(config.template.files.model)
+    add_code_to_module(template_model_path, models_folder_path, name, {'model_name': name, 'model_name_lower': name.lower(), 'table_name': tablename})
+    add_file_to_module(models_folder_path, name)
+    
+    service_template_path = Path(config.template.files.service)
+    service_folder_path = Path(config.project.folders.services)
+    add_code_to_module(service_template_path, service_folder_path, f"{name}Service", {'model_name': name})
+    add_file_to_module(service_folder_path, f"{name}Service")
+    
+    controller_template_path = Path(config.template.files.controller)
+    controller_folder_path = Path(config.project.folders.controllers)
+    add_code_to_module(controller_template_path, controller_folder_path, f"{name}Controller", {})
+    
+    routes_template_path = Path(config.template.files.endpoint)
+    routes_folder_path = Path(config.project.folders.endpoints)
+    add_code_to_module(routes_template_path, routes_folder_path, f"{name}Router", {'model_name': name, 'model_name_lower': name.lower()})
+    add_file_to_module(routes_folder_path, f"{name}Router", f"{name.lower()}_router")
+    
+    index_code = Path(config.project.folders.root).joinpath('__init__.py').read_text()
+
+    search_return = index_code.index('return app')
+
+    block_insert_code = f"""from .routes import {name.lower()}_router
+    app.register_blueprint({name.lower()}_router, url_prefix='/{name.lower()}')
+
+    """
+
+    index_code = index_code[:search_return] + block_insert_code + index_code[search_return:]
+    Path(config.project.folders.root).joinpath('__init__.py').write_text(index_code)

spa_cli/src/project/project.py

@@ -0,0 +1,149 @@
+from ...globals import Constants, DRIVERS, load_config
+from ..utils.template_gen import generate_project_template
+from ..utils.install_local_layers import install_layers, build_layers
+from ..utils.up_local_server import main as up_local_server
+from ..utils.build import build_lambdas, build_lambda_stack, build_api
+
+import os
+import json
+import typer
+from typing import cast
+from click.types import Choice
+from pathlib import Path
+from shutil import copytree, rmtree
+
+app = typer.Typer()
+
+@app.command('init')
+def init_project(
+        pattern_version: str = typer.Option(help='Version del patron.', default='latest')
+    ):
+    """
+    Genera un nuevo proyecto con template
+    """
+    db_config = {
+        "db_engine": None,
+        "db_driver": None,
+        "secret_name": '',
+    }
+    project_name = typer.prompt("Nombre del proyecto")
+    project_description = typer.prompt("Descripción del proyecto")
+    
+    author_name = typer.prompt("Nombre del autor", default=os.getlogin())
+    author_email = typer.prompt("Email del autor", default="")
+
+    dbChoices = Choice([
+        Constants.MYSQL_ENGINE.value,
+        Constants.POSTGRESQL_ENGINE.value
+    ])
+    db_config['db_engine'] = typer.prompt(
+        "Elija su motor de base de datos",
+        Constants.MYSQL_ENGINE.value,
+        show_choices=True,
+        type=dbChoices
+    )
+    
+    aws_region = typer.prompt("Región de AWS", default="us-east-1")
+    
+    db_config['db_driver'] = DRIVERS[Constants.MYSQL_ENGINE.value]
+    db_config['secret_name'] = typer.prompt("Escriba el nombre del secreto para las credenciales de la base de datos - Revise la documentación para el formato correcto")
+    
+    generate_project_template(
+        project_name,
+        author_name=author_name,
+        author_email=author_email,
+        **db_config,
+        aws_region=aws_region,
+        pattern_version=pattern_version,
+        project_description=project_description
+    )
+        
+    
+    local_project_dir = Path(os.getcwd()).joinpath(project_name).joinpath('.spa')
+    if not local_project_dir.exists():
+        os.mkdir(local_project_dir)
+    
+    with open(local_project_dir.joinpath('project.json'), 'w') as f:
+        json.dump({
+            "project_name": project_name,
+            "dbDialect": db_config['db_engine'],
+            "pattern_version": pattern_version
+        }, f)
+    
+
+@app.command('install')
+def install_project():
+    try:
+        project_config = load_config()
+    except:
+        typer.echo('No se puedo leer la configuracion del proyecto', color=typer.colors.RED)
+        raise typer.Abort()
+    install_layers(project_config)
+
+@app.command('run-api')
+def run_app():
+    try:
+        project_config = load_config()
+    except:
+        typer.echo('No se puedo leer la configuracion del proyecto', color=typer.colors.RED)
+        raise typer.Abort()
+    
+    typer.echo('Iniciando servidor local')
+    up_local_server(project_config)
+    
+
+@app.command('build')
+def build_project():
+    try:
+        project_config = load_config()
+    except:
+        typer.echo('No se puedo leer la configuracion del proyecto', color=typer.colors.RED)
+        raise typer.Abort()
+    
+    typer.echo('Construyendo proyecto')
+    build_path = Path(os.getcwd()).joinpath('build')
+    if build_path.exists():
+        for item in os.listdir(build_path):
+            item_path = os.path.join(build_path, item)
+            if os.path.isdir(item_path):
+                try:
+                    rmtree(item_path)
+                    typer.echo(f"Deleted directory: {item_path}")
+                except OSError as e:
+                    typer.echo(f"Error deleting directory '{item_path}': {e}")
+        
+        rmtree(build_path)
+        typer.echo(f"Deleted directory: {build_path}")
+    os.mkdir(build_path)
+
+    copytree(
+        Path(os.getcwd()).joinpath('infra'),
+        build_path,
+        dirs_exist_ok=True
+    )
+
+    layers_path = Path(os.getcwd()) / project_config.project.folders.layers
+    lambdas_path = Path(os.getcwd()) / project_config.project.folders.lambdas
+    output_layers_path = build_path / 'tmp_build_layer'
+
+    typer.echo(f'Building layers from {layers_path} into {output_layers_path}...')
+    build_layers(layers_path, output_layers_path)
+
+    typer.echo(f'Building lambdas from {lambdas_path}...')
+    build_lambdas(lambdas_path, build_path / 'components' / 'lambdas')
+
+    typer.echo('Building lambda stack...')
+    build_lambda_stack(
+        build_lambdas_path=build_path / "components" / "lambdas",
+        environment=os.getenv("ENVIRONMENT") or "dev",
+        app_name=os.getenv("APP_NAME") or cast(str, project_config.project.definition.name)
+    )
+
+    typer.echo('Building API definition...')
+    build_api(
+        api_path=Path(project_config.project.definition.base_api),
+        lambdas_path=build_path / "components" / "lambdas",
+        output_file=build_path / "components" / "openapi.json"
+    )
+
+    typer.echo('Build completed.')