sucuri-framework 0.0.1__py3-none-any.whl

sucuri_framework/__init__.py

@@ -0,0 +1,3 @@
+from sucuri_framework.core import SucuriApp
+
+__all__ = ["SucuriApp"]

sucuri_framework/cli/ast_utils.py

@@ -0,0 +1,41 @@
+import re
+from pathlib import Path
+
+def inject_module_into_app(app_module_path: Path, import_path: str, module_var: str) -> bool:
+    """
+    Injeta cirurgicamente a importação e a declaração de um módulo no arquivo
+    app_module.py usando a sintaxe de instância (ex: app_module.include_module(...))
+    
+    Retorna True se alterou, False se já existia.
+    """
+    if not app_module_path.exists():
+        return False
+        
+    content = app_module_path.read_text(encoding="utf-8")
+    
+    # Previne duplicidade
+    if f"import {module_var}" in content or module_var in content:
+        return False
+
+    # 1. Injetar o Import no topo do arquivo (após o último import)
+    import_statement = f"from {import_path} import {module_var}\n"
+    
+    # Achar o último import para colocar logo depois
+    import_matches = list(re.finditer(r'^import .*|^from .* import .*', content, flags=re.MULTILINE))
+    if import_matches:
+        last_import = import_matches[-1]
+        insert_pos = last_import.end() + 1
+        content = content[:insert_pos] + import_statement + content[insert_pos:]
+    else:
+        # Se não houver nenhum import, joga no topo
+        content = import_statement + "\n" + content
+
+    # 2. Injetar a chamada .include_module no final do arquivo
+    call_statement = f"app_module.include_module({module_var})\n"
+    
+    if not content.endswith('\n'):
+        content += '\n'
+    content += call_statement
+    
+    app_module_path.write_text(new_content := content, encoding="utf-8")
+    return True

sucuri_framework/cli/cli.py

@@ -0,0 +1,47 @@
+import typer
+from importlib import metadata
+
+from sucuri_framework.cli.commands_run import run_server_dev, run_server_prod
+from sucuri_framework.cli.commands_new import new_project
+from sucuri_framework.cli.commands_generate import generate_app
+from sucuri_framework.cli.commands_db import db_app
+
+app = typer.Typer(help="CLI oficial do Sucuri Framework")
+
+# Adiciona grupos de comando
+app.add_typer(generate_app, name="generate")
+app.add_typer(db_app, name="db")
+
+@app.command(name="version")
+def _version():
+    """Mostra a versão atual do Sucuri."""
+    try:
+        versao = metadata.version("sucuri")
+        print(f"🐍 Sucuri Framework v{versao}")
+    except metadata.PackageNotFoundError:
+        print("🐍 Sucuri Framework (Versão não encontrada)")
+
+@app.command(name="dev")
+def _dev():
+    """Iniciar o Servidor de Desenvolvimento (Hot Reload)."""
+    run_server_dev()
+
+@app.command(name="run")
+def _run():
+    """Iniciar o Servidor de Produção."""
+    run_server_prod()
+
+from sucuri_framework.cli.commands_task import run_task
+
+@app.command(name="task")
+def _task(nome_da_tarefa: str):
+    """Rodar scripts de automação customizados definidos no pyproject.toml."""
+    run_task(nome_da_tarefa)
+
+@app.command(name="new")
+def _new(nome_do_projeto: str):
+    """Criar um projeto novo."""
+    new_project(nome_do_projeto)
+
+if __name__ == "__main__":
+    app()

sucuri_framework/cli/commands_db.py

@@ -0,0 +1,34 @@
+import subprocess
+import typer
+
+db_app = typer.Typer(help="Operações de Banco de Dados")
+
+@db_app.command("init")
+def db_init():
+    """Inicializar o controle de versão do banco (primeira vez)."""
+    print("Inicializando o banco de dados...")
+    try:
+        subprocess.run(["aerich", "init", "-t", "app.db.TORTOISE_ORM"], check=True)
+        subprocess.run(["aerich", "init-db"], check=True)
+        print("Banco inicializado com sucesso!")
+    except Exception as e:
+        print(f"Falha ao inicializar o banco: {e}")
+
+@db_app.command("migrate")
+def db_migrate(motivo: str):
+    """Gerar e Aplicar Migrações de Banco."""
+    print(f"Gerando migração: {motivo}")
+    # Usa aerich debaixo dos panos silenciosamente
+    try:
+        subprocess.run(["aerich", "migrate", "--name", motivo], check=True)
+    except Exception as e:
+        print(f"Falha ao gerar migração: {e}")
+
+@db_app.command("upgrade")
+def db_upgrade():
+    """Aplicar Migrações de Banco (Upgrade)."""
+    print("Aplicando migrações...")
+    try:
+        subprocess.run(["aerich", "upgrade"], check=True)
+    except Exception as e:
+        print(f"Falha ao aplicar migração: {e}")

sucuri_framework/cli/commands_generate.py

@@ -0,0 +1,548 @@
+from pathlib import Path
+import typer
+import re
+
+generate_app = typer.Typer(help="Geradores de código para o framework")
+
+def to_snake_case(name: str) -> str:
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+from sucuri_framework.cli.ast_utils import inject_module_into_app
+
+def get_names(nome: str):
+    # Returns (snake_case, CamelCase)
+    camel = nome[0].upper() + nome[1:] if nome else nome
+    snake = to_snake_case(camel)
+    return snake, camel
+
+@generate_app.command("resource", help="Gera Model, Schema, Controller e Service.")
+def generate_resource(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto (onde a pasta 'app' está).")
+        return
+        
+    print(f"Gerando resource para: {nome_capitalized}...")
+    
+    # Gerando o Model
+    model_content = f'''from sucuri_framework.models import Model, fields
+
+class {nome_capitalized}(Model):
+    # 'id' (int) é gerado automaticamente pelo Tortoise/Sucuri
+    nome = fields.CharField(max_length=255)
+
+    class Meta:
+        table = "{nome_lower}s"
+'''
+    model_path = app_dir / "models" / f"{nome_lower}.py"
+    if no_overwrite and model_path.exists():
+        print(f"Ignorado: {model_path} já existe.")
+    else:
+        model_path.parent.mkdir(parents=True, exist_ok=True)
+        model_path.write_text(model_content)
+        print(f"Criado: {model_path}")
+    
+    # Gerando o Schema
+    schema_content = f'''from sucuri_framework.schema import Schema
+
+class Criar{nome_capitalized}Schema(Schema):
+    nome: str
+
+class Resposta{nome_capitalized}Schema(Schema):
+    id: int
+    nome: str
+'''
+    schema_path = app_dir / "schemas" / f"{nome_lower}.py"
+    if no_overwrite and schema_path.exists():
+        print(f"Ignorado: {schema_path} já existe.")
+    else:
+        schema_path.parent.mkdir(parents=True, exist_ok=True)
+        schema_path.write_text(schema_content)
+        print(f"Criado: {schema_path}")
+    
+    # Gerando o Controller
+    controller_content = f'''from sucuri_framework.routing import Controller
+from sucuri_framework.di import Inject
+from app.models.{nome_lower} import {nome_capitalized}
+from app.schemas.{nome_lower} import Criar{nome_capitalized}Schema, Resposta{nome_capitalized}Schema
+from app.services.{nome_lower} import {nome_capitalized}Service
+
+{nome_lower}s_controller = Controller(prefix="/api/{nome_lower}s", tags=["{nome_capitalized}s"])
+
+@{nome_lower}s_controller.get("/", response_model=list[Resposta{nome_capitalized}Schema])
+async def listar_{nome_lower}s(service: {nome_capitalized}Service = Inject()):
+    # Exemplo delegando pro service:
+    # return await service.listar_todos()
+    return await {nome_capitalized}.all()
+
+@{nome_lower}s_controller.post("/", response_model=Resposta{nome_capitalized}Schema)
+async def criar_{nome_lower}(payload: Criar{nome_capitalized}Schema, service: {nome_capitalized}Service = Inject()):
+    # Exemplo delegando pro service:
+    # novo = await service.criar_novo(payload.model_dump())
+    novo = await {nome_capitalized}.create(**payload.model_dump())
+    return novo
+'''
+    controller_path = app_dir / "controllers" / f"{nome_lower}.py"
+    if no_overwrite and controller_path.exists():
+        print(f"Ignorado: {controller_path} já existe.")
+    else:
+        controller_path.parent.mkdir(parents=True, exist_ok=True)
+        controller_path.write_text(controller_content)
+        print(f"Criado: {controller_path}")
+
+    # Gerando o Service
+    service_content = f'''from sucuri_framework.di import Injectable
+from app.models.{nome_lower} import {nome_capitalized}
+from app.schemas.{nome_lower} import Criar{nome_capitalized}Schema
+
+@Injectable()
+class {nome_capitalized}Service:
+    """Camada de Regras de Negócios para {nome_capitalized}."""
+    pass
+'''
+    service_path = app_dir / "services" / f"{nome_lower}.py"
+    if no_overwrite and service_path.exists():
+        print(f"Ignorado: {service_path} já existe.")
+    else:
+        service_path.parent.mkdir(parents=True, exist_ok=True)
+        service_path.write_text(service_content)
+        print(f"Criado: {service_path}")
+        
+    # Gerando o Módulo (AST Inject)
+    generate_module(nome, no_overwrite, no_tests)
+    
+    
+    # Gerando Teste
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+            
+        test_content = f'''import pytest
+
+# TODO: Importar dependencias para teste (app, client, db, etc)
+
+def test_listar_{nome_lower}s():
+    # Exemplo de teste placeholder
+    assert True
+'''
+        test_path = test_dir / f"test_{nome_lower}.py"
+        if no_overwrite and test_path.exists():
+            print(f"Ignorado: {test_path} já existe.")
+        else:
+            test_path.write_text(test_content)
+            print(f"Criado: {test_path}")
+
+    print("Resource gerado com sucesso!")
+
+@generate_app.command("controller", help="Gera apenas a declaração de um Controller com rotas vazias.")
+def generate_controller(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto (onde a pasta 'app' está).")
+        return
+        
+    print(f"Gerando controller para: {nome_capitalized}...")
+    
+    content = f'''from sucuri_framework.routing import Controller
+from sucuri_framework.di import Inject
+
+{nome_lower}_controller = Controller(prefix="/api/{nome_lower}", tags=["{nome_capitalized}"])
+
+@{nome_lower}_controller.get("/")
+async def listar_{nome_lower}():
+    return {{"message": "Rota de {nome_capitalized}"}}
+'''
+    path = app_dir / "controllers" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_controller.py"
+        if no_overwrite and test_path.exists():
+            pass
+        else:
+            test_path.write_text(f"def test_{nome_lower}_controller():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("model", help="Gera um modelo do banco de dados (Tortoise/Active Record).")
+def generate_model(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto (onde a pasta 'app' está).")
+        return
+        
+    print(f"Gerando model para: {nome_capitalized}...")
+    
+    content = f'''from sucuri_framework.models import Model, fields
+
+class {nome_capitalized}(Model):
+    descricao = fields.CharField(max_length=255)
+
+    class Meta:
+        table = "{nome_lower}s"
+'''
+    path = app_dir / "models" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_model.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_model():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("schema", help="Gera um Schema (Pydantic/Sucuri Schema) para validação de dados.")
+def generate_schema(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto (onde a pasta 'app' está).")
+        return
+        
+    print(f"Gerando schema para: {nome_capitalized}...")
+    
+    content = f'''from sucuri_framework.schema import Schema
+
+class Criar{nome_capitalized}Schema(Schema):
+    pass
+'''
+    path = app_dir / "schemas" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_schema.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_schema():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("service", help="Gera uma classe ou módulo de serviço para lógica de negócios.")
+def generate_service(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower = nome.lower()
+    nome_capitalized = nome.capitalize()
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto (onde a pasta 'app' está).")
+        return
+        
+    print(f"Gerando service para: {nome_capitalized}...")
+    
+    content = f'''from sucuri_framework.di import Injectable
+
+@Injectable()
+class {nome_capitalized}Service:
+    """Camada de Regras de Negócios para {nome_capitalized}."""
+    async def processar_{nome_lower}(self, dados):
+        pass
+'''
+    path = app_dir / "services" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_service.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_service():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("middleware", help="Gera um middleware (ASGI/FastAPI) para interceptar requisições.")
+def generate_middleware(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto.")
+        return
+        
+    print(f"Gerando middleware para: {nome_capitalized}...")
+    
+    content = f'''from sucuri_framework.routing import BaseMiddleware
+
+class {nome_capitalized}Middleware(BaseMiddleware):
+    async def dispatch(self, request, call_next):
+        print(f"Recebida req: {{request.url}}")
+        response = await call_next(request)
+        return response
+'''
+    path = app_dir / "middlewares" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_middleware.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_middleware():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("task", help="Gera um worker/task para ser processado em background.")
+def generate_task(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto.")
+        return
+        
+    print(f"Gerando task para: {nome_capitalized}...")
+    
+    content = f'''async def executar_{nome_lower}(payload):
+    # Lógica que será executada assincronamente pelo BackgroundWorker
+    pass
+'''
+    path = app_dir / "tasks" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_task.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_task():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("decorator", help="Gera um decorator customizado.")
+def generate_decorator(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto.")
+        return
+        
+    print(f"Gerando decorator para: {nome_capitalized}...")
+    
+    content = f'''def {nome_lower}(*args_decorator):
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            # validação de exemplo
+            return await func(*args, **kwargs)
+        return wrapper
+    return decorator
+'''
+    path = app_dir / "decorators" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_decorator.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_decorator():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("guard", help="Gera um guard para proteção de rotas (Autorização/Autenticação).")
+def generate_guard(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto.")
+        return
+        
+    print(f"Gerando guard para: {nome_capitalized}...")
+    
+    content = f'''from sucuri_framework.guards import BaseGuard
+from fastapi import Request, HTTPException
+
+class {nome_capitalized}Guard(BaseGuard):
+    async def can_activate(self, request: Request) -> bool:
+        # Exemplo: validar headers
+        # token = request.headers.get("Authorization")
+        # if not token:
+        #     raise HTTPException(status_code=401, detail="Unauthorized")
+        return True
+'''
+    path = app_dir / "guards" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_guard.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_guard():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("filter", help="Gera um Exception Filter customizado para interceptar erros globais.")
+def generate_filter(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto.")
+        return
+        
+    print(f"Gerando exception filter para: {nome_capitalized}...")
+    
+    content = f'''from sucuri_framework.exceptions import ExceptionFilter, Catch
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+# Altere a classe "Exception" pela exceção real que deseja interceptar
+@Catch(Exception)
+class {nome_capitalized}Filter(ExceptionFilter):
+    async def catch(self, exception: Exception, request: Request):
+        return JSONResponse(
+            status_code=500,
+            content={{
+                "error": "Erro Interceptado",
+                "message": str(exception),
+                "path": request.url.path
+            }}
+        )
+'''
+    path = app_dir / "filters" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_filter.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_filter():\n    assert True\n")
+            print(f"Criado: {test_path}")
+
+@generate_app.command("module", help="Gera um Módulo (@Module) isolado e injeta no app_module.py.")
+def generate_module(
+    nome: str, 
+    no_overwrite: bool = typer.Option(False, "--no-overwrite", help="Não sobrescreve arquivos que já existem"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Não gerar arquivos de teste")
+):
+    nome_lower, nome_capitalized = get_names(nome)
+    app_dir = Path("app")
+    if not app_dir.exists():
+        print("Erro: Deve ser executado na raiz do projeto.")
+        return
+        
+    print(f"Gerando module para: {nome_capitalized}...")
+    
+    path = app_dir / "modules" / f"{nome_lower}.py"
+    if no_overwrite and path.exists():
+        print(f"Ignorado: {path} já existe.")
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        # Note: A importação do controller e service pode quebrar se não existirem,
+        # mas como é scaffold a intenção é tê-los ou que o dev ajuste.
+        content = f'''from sucuri_framework.module import Module
+# Remova/Altere os imports abaixo caso o resource não exista
+try:
+    from app.controllers.{nome_lower} import {nome_lower}s_controller
+except ImportError:
+    {nome_lower}s_controller = None
+
+{nome_lower}_module = Module("{nome_lower}")
+if {nome_lower}s_controller:
+    {nome_lower}_module.include_controller({nome_lower}s_controller)
+'''
+        path.write_text(content)
+        print(f"Criado: {path}")
+
+    # Injeção via AST
+    app_module_path = app_dir / "app_module.py"
+    foi_injetado = inject_module_into_app(
+        app_module_path,
+        import_path=f"app.modules.{nome_lower}",
+        module_var=f"{nome_lower}_module"
+    )
+    if foi_injetado:
+        print(f"Injetado: {nome_lower}_module adicionado com sucesso em app_module.py")
+    else:
+        print(f"Ignorado: {nome_lower}_module já existe em app_module.py ou arquivo não encontrado.")
+
+    if not no_tests:
+        test_dir = Path("tests")
+        test_dir.mkdir(parents=True, exist_ok=True)
+        test_path = test_dir / f"test_{nome_lower}_module.py"
+        if not (no_overwrite and test_path.exists()):
+            test_path.write_text(f"def test_{nome_lower}_module():\n    assert True\n")
+            print(f"Criado: {test_path}")