konecty-sdk-python 0.1.0__tar.gz → 0.3.0__tar.gz

{konecty_sdk_python-0.1.0 → konecty_sdk_python-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konecty-sdk-python
-Version: 0.1.0
+Version: 0.3.0
 Summary: Konecty SDK Python
 Author-email: Leonardo Leal <leonardo.leal@konecty.com>, Derotino Silveira <derotino.silveira@konecty.com>
 License: MIT
@@ -28,3 +28,14 @@ Description-Content-Type: text/markdown
 ## Konecty Python SDK
 
 > 🛠️ Work in progress
+
+#### Build & Publish
+
+It is needed to increase the version number on the [pyproject](./pyproject.toml) file.
+
+```sh
+
+uv build
+uvx twine upload --config-file .pypirc --skip-existing dist/*
+
+```

konecty_sdk_python-0.3.0/README.md

@@ -0,0 +1,14 @@
+## Konecty Python SDK
+
+> 🛠️ Work in progress
+
+#### Build & Publish
+
+It is needed to increase the version number on the [pyproject](./pyproject.toml) file.
+
+```sh
+
+uv build
+uvx twine upload --config-file .pypirc --skip-existing dist/*
+
+```

konecty_sdk_python-0.3.0/cli/__init__.py

@@ -0,0 +1,38 @@
+"""CLI tools for Konecty metadata management."""
+
+import click
+from rich.console import Console
+
+console = Console()
+
+
+@click.group()
+def cli():
+    """Konecty CLI tools for metadata management."""
+    pass
+
+
+# Import commands after cli group is defined to avoid circular imports
+from .apply import apply_command
+from .backup import backup_command
+from .pull import pull_command
+
+# Add commands to the group
+cli.add_command(apply_command)
+cli.add_command(backup_command)
+cli.add_command(pull_command)
+
+
+def main():
+    """Entry point for the CLI."""
+    import asyncio
+    import sys
+
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+    asyncio.run(cli())
+
+
+if __name__ == "__main__":
+    main()

{konecty_sdk_python-0.1.0 → konecty_sdk_python-0.3.0}/cli/apply.py

@@ -13,6 +13,7 @@ import json
 from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Set, Tuple, TypedDict, cast
 
+import click
 import inquirer
 from pymongo import MongoClient
 from rich.console import Console
@@ -117,7 +118,9 @@ async def apply_document(
     if doc_files["document"]:
         doc_data = load_json_file(doc_files["document"][0])
         if doc_data:
-            existing_doc = collection.find_one({"name": doc_name, "type": {"$in": ["composite", "document"]}})
+            existing_doc = collection.find_one(
+                {"name": doc_name, "type": {"$in": ["composite", "document"]}}
+            )
 
             if existing_doc and is_equal_documents(doc_data, existing_doc):
                 skipped.append(f"⚡ {doc_name} (document) [identical]")
@@ -125,7 +128,12 @@ async def apply_document(
                 if not dry_run:
                     try:
                         collection.replace_one(
-                            {"name": doc_name, "type": {"$in": ["composite", "document"]}}, doc_data, upsert=True
+                            {
+                                "name": doc_name,
+                                "type": {"$in": ["composite", "document"]},
+                            },
+                            doc_data,
+                            upsert=True,
                         )
                         applied.append(f"✓ {doc_name} (document)")
                     except Exception as error:
@@ -142,27 +150,43 @@ async def apply_document(
         for file_path in doc_files[type_name_key]:
             data = load_json_file(file_path)
             if data:
-                existing_data = collection.find_one({"name": data["name"], "type": type_name, "document": doc_name})
+                existing_data = collection.find_one(
+                    {"name": data["name"], "type": type_name, "document": doc_name}
+                )
 
                 if existing_data and is_equal_documents(data, existing_data):
-                    skipped.append(f"⚡ {doc_name}/{type_name}/{data['name']} [identical]")
+                    skipped.append(
+                        f"⚡ {doc_name}/{type_name}/{data['name']} [identical]"
+                    )
                 else:
                     if not dry_run:
                         try:
                             collection.replace_one(
-                                {"name": data["name"], "type": type_name, "document": doc_name}, data, upsert=True
+                                {
+                                    "name": data["name"],
+                                    "type": type_name,
+                                    "document": doc_name,
+                                },
+                                data,
+                                upsert=True,
                             )
                             applied.append(f"✓ {doc_name}/{type_name}/{data['name']}")
                         except Exception as error:
-                            errors.append(f"✗ {doc_name}/{type_name}/{data['name']}: {str(error)}")
+                            errors.append(
+                                f"✗ {doc_name}/{type_name}/{data['name']}: {str(error)}"
+                            )
                     else:
-                        applied.append(f"✓ {doc_name}/{type_name}/{data['name']} [dry-run]")
+                        applied.append(
+                            f"✓ {doc_name}/{type_name}/{data['name']} [dry-run]"
+                        )
 
     # Hooks
     for file_path in doc_files["hook"]:
         data = file_path.read_text()
         if data:
-            existing_data = collection.find_one({"name": doc_name, "type": {"$in": ["composite", "document"]}})
+            existing_data = collection.find_one(
+                {"name": doc_name, "type": {"$in": ["composite", "document"]}}
+            )
             hook_name = file_path.stem
             if existing_data:
                 if existing_data.get(hook_name, None) == data:
@@ -171,7 +195,10 @@ async def apply_document(
                     if not dry_run:
                         try:
                             collection.update_one(
-                                {"name": doc_name, "type": {"$in": ["composite", "document"]}},
+                                {
+                                    "name": doc_name,
+                                    "type": {"$in": ["composite", "document"]},
+                                },
                                 {"$set": {hook_name: data}},
                             )
                             applied.append(f"✓ {doc_name}/{hook_name}")
@@ -195,7 +222,10 @@ async def prune_documents(
     # Encontra documentos no banco que não existem localmente
     remote_docs = set(
         doc["name"]
-        for doc in collection.find({"type": {"$in": ["composite", "document"]}, "name": {"$ne": "_id"}}, {"name": 1})
+        for doc in collection.find(
+            {"type": {"$in": ["composite", "document"]}, "name": {"$ne": "_id"}},
+            {"name": 1},
+        )
     )
 
     to_remove = remote_docs - local_docs
@@ -204,7 +234,9 @@ async def prune_documents(
         if not dry_run:
             try:
                 # Remove documento principal
-                collection.delete_one({"name": doc_name, "type": {"$in": ["composite", "document"]}})
+                collection.delete_one(
+                    {"name": doc_name, "type": {"$in": ["composite", "document"]}}
+                )
                 # Remove documentos relacionados
                 collection.delete_many({"document": doc_name})
                 pruned.append(f"✓ {doc_name}")
@@ -262,7 +294,9 @@ async def apply_namespace(
         if not dry_run:
             try:
                 if existing_namespace:
-                    collection.update_one({"_id": "Namespace"}, {"$set": namespace_data})
+                    collection.update_one(
+                        {"_id": "Namespace"}, {"$set": namespace_data}
+                    )
                 else:
                     collection.insert_one({**base_namespace, **namespace_data})
                 applied.append("✓ Namespace.json")
@@ -274,20 +308,41 @@ async def apply_namespace(
     return applied, errors, skipped
 
 
+@click.command(name="apply")
+@click.option("--metadata-dir", default="metadata", help="Diretório com os metadados")
+@click.option("--host", default="localhost", help="Host do MongoDB")
+@click.option("--port", type=int, default=27017, help="Porta do MongoDB")
+@click.option("--database", default="default", help="Nome do banco de dados")
+@click.option("--username", help="Usuário do MongoDB")
+@click.option("--password", help="Senha do MongoDB")
+@click.option("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
+@click.option("--document", help="Nome do documento para aplicar")
+@click.option(
+    "--prune", is_flag=True, help="Remove documentos que não existem localmente"
+)
+@click.option("--dry-run", is_flag=True, help="Simula as alterações sem aplicá-las")
+@click.option("--direct-connection", is_flag=True, help="Usa conexão direta ao MongoDB")
+@click.option(
+    "--retry-writes",
+    is_flag=True,
+    default=True,
+    help="Tenta reescrever em caso de falha",
+)
+@click.option("--w", default="majority", help="Nível de escrita do MongoDB")
 async def apply_command(
-    metadata_dir: str = "metadata",
-    host: str = "localhost",
-    port: int = 27017,
-    database: str = "default",
-    username: Optional[str] = None,
-    password: Optional[str] = None,
-    replicaset: Optional[str] = None,
-    document: Optional[str] = None,
-    prune: bool = False,
-    dry_run: bool = False,
-    direct_connection: bool = False,
-    retry_writes: bool = True,
-    w: str = "majority",
+    metadata_dir: str,
+    host: str,
+    port: int,
+    database: str,
+    username: Optional[str],
+    password: Optional[str],
+    replicaset: Optional[str],
+    document: Optional[str],
+    prune: bool,
+    dry_run: bool,
+    direct_connection: bool,
+    retry_writes: bool,
+    w: str,
 ) -> None:
     """Aplica alterações locais ao MongoDB."""
     metadata_path = Path(metadata_dir).resolve()
@@ -314,7 +369,11 @@ async def apply_command(
         uri = f"mongodb://{host}:{port}{uri_suffix}"
 
     client = MongoClient(
-        uri, serverSelectionTimeoutMS=30000, connectTimeoutMS=20000, socketTimeoutMS=20000, maxPoolSize=1
+        uri,
+        serverSelectionTimeoutMS=30000,
+        connectTimeoutMS=20000,
+        socketTimeoutMS=20000,
+        maxPoolSize=1,
     )
     db = client[database]
     collection = db["MetaObjects"]
@@ -331,7 +390,10 @@ async def apply_command(
         table.add_column("Erros")
         if namespace_applied or namespace_errors or namespace_skipped:
             table.add_row(
-                "@Namespace", "\n".join(namespace_applied), "\n".join(namespace_skipped), "\n".join(namespace_errors)
+                "@Namespace",
+                "\n".join(namespace_applied),
+                "\n".join(namespace_skipped),
+                "\n".join(namespace_errors),
             )
         client.close()
         console.print(table)
@@ -374,7 +436,9 @@ async def apply_command(
         return
 
     # Aplica o Namespace primeiro
-    namespace_applied, namespace_errors, namespace_skipped = await apply_namespace(collection, metadata_path, dry_run)
+    namespace_applied, namespace_errors, namespace_skipped = await apply_namespace(
+        collection, metadata_path, dry_run
+    )
 
     table = Table(title="Resultados da Aplicação")
     table.add_column("Documento")
@@ -384,72 +448,58 @@ async def apply_command(
 
     if namespace_applied or namespace_errors or namespace_skipped:
         table.add_row(
-            "@Namespace", "\n".join(namespace_applied), "\n".join(namespace_skipped), "\n".join(namespace_errors)
+            "@Namespace",
+            "\n".join(namespace_applied),
+            "\n".join(namespace_skipped),
+            "\n".join(namespace_errors),
         )
 
     with Progress() as progress:
-        task = progress.add_task("[cyan]Aplicando alterações...", total=len(docs_to_process))
+        task = progress.add_task(
+            "[cyan]Aplicando alterações...", total=len(docs_to_process)
+        )
 
         for doc_name in docs_to_process:
-            applied, errors, skipped = await apply_document(collection, doc_name, all_files[doc_name], dry_run)
+            applied, errors, skipped = await apply_document(
+                collection, doc_name, all_files[doc_name], dry_run
+            )
 
-            table.add_row(doc_name, "\n".join(applied), "\n".join(skipped), "\n".join(errors) if errors else "")
+            table.add_row(
+                doc_name,
+                "\n".join(applied),
+                "\n".join(skipped),
+                "\n".join(errors) if errors else "",
+            )
 
             progress.update(task, advance=1)
 
     if prune:
-        pruned, prune_errors = await prune_documents(collection, set(all_files.keys()), dry_run)
+        pruned, prune_errors = await prune_documents(
+            collection, set(all_files.keys()), dry_run
+        )
         if pruned or prune_errors:
-            table.add_row("Prune", "\n".join(pruned), "", "\n".join(prune_errors) if prune_errors else "")
+            table.add_row(
+                "Prune",
+                "\n".join(pruned),
+                "",
+                "\n".join(prune_errors) if prune_errors else "",
+            )
 
     client.close()
     console.print(table)
 
 
 def main():
-    """Função principal para execução via linha de comando."""
-    import argparse
+    """Entry point for the CLI."""
     import asyncio
     import sys
 
-    parser = argparse.ArgumentParser(description="Aplica alterações locais ao MongoDB")
-    parser.add_argument("--host", default="localhost", help="Host do MongoDB")
-    parser.add_argument("--port", type=int, default=27017, help="Porta do MongoDB")
-    parser.add_argument("--database", required=True, help="Nome do banco de dados")
-    parser.add_argument("--metadata-dir", default="metadata", help="Diretório dos metadados")
-    parser.add_argument("--username", help="Usuário do MongoDB")
-    parser.add_argument("--password", help="Senha do MongoDB")
-    parser.add_argument("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
-    parser.add_argument("--document", help="Nome do documento específico para aplicar")
-    parser.add_argument("--prune", action="store_true", help="Remove documentos que não existem localmente")
-    parser.add_argument("--dry-run", action="store_true", help="Executa sem fazer alterações")
-    parser.add_argument("--direct-connection", action="store_true", help="Usa conexão direta com o MongoDB")
-    parser.add_argument("--no-retry-writes", action="store_true", help="Desativa retry writes")
-    parser.add_argument("--write-concern", default="majority", help="Write concern (ex: majority, 1)")
-
-    args = parser.parse_args()
-
     if sys.platform == "win32":
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
-    asyncio.run(
-        apply_command(
-            metadata_dir=args.metadata_dir,
-            host=args.host,
-            port=args.port,
-            database=args.database,
-            username=args.username,
-            password=args.password,
-            replicaset=args.replicaset,
-            document=args.document,
-            prune=args.prune,
-            dry_run=args.dry_run,
-            direct_connection=args.direct_connection,
-            retry_writes=not args.no_retry_writes,
-            w=args.write_concern,
-        )
-    )
+    asyncio.run(apply_command())
 
 
 if __name__ == "__main__":
     main()
+    main()

{konecty_sdk_python-0.1.0 → konecty_sdk_python-0.3.0}/cli/backup.py

@@ -7,6 +7,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Optional
 
+import click
 from pymongo import MongoClient
 from rich.console import Console
 from rich.progress import Progress
@@ -14,15 +15,24 @@ from rich.progress import Progress
 console = Console()
 
 
+@click.command(name="backup")
+@click.option("--host", default="localhost", help="Host do MongoDB")
+@click.option("--port", type=int, default=27017, help="Porta do MongoDB")
+@click.option("--database", required=True, help="Nome do banco de dados")
+@click.option("--output", default="backups", help="Diretório para salvar o backup")
+@click.option("--username", help="Usuário do MongoDB")
+@click.option("--password", help="Senha do MongoDB")
+@click.option("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
+@click.option("--version", help="Rótulo de versão para o arquivo de backup")
 async def backup_command(
-    host: str = "localhost",
-    port: int = 27017,
-    database: str = "default",
-    output: str = "backups",
-    username: Optional[str] = None,
-    password: Optional[str] = None,
-    replicaset: Optional[str] = None,
-    version: Optional[str] = None,
+    host: str,
+    port: int,
+    database: str,
+    output: str,
+    username: Optional[str],
+    password: Optional[str],
+    replicaset: Optional[str],
+    version: Optional[str],
 ) -> None:
     """Gera backup dos documentos do MongoDB."""
     output_dir = Path(output).resolve()
@@ -35,7 +45,14 @@ async def backup_command(
 
     uri_params = []
     if replicaset:
-        uri_params.extend([f"replicaSet={replicaset}", "directConnection=false", "retryWrites=true", "w=majority"])
+        uri_params.extend(
+            [
+                f"replicaSet={replicaset}",
+                "directConnection=false",
+                "retryWrites=true",
+                "w=majority",
+            ]
+        )
 
     uri_suffix = f"?{'&'.join(uri_params)}" if uri_params else ""
 
@@ -45,7 +62,11 @@ async def backup_command(
         uri = f"mongodb://{host}:{port}{uri_suffix}"
 
     client = MongoClient(
-        uri, serverSelectionTimeoutMS=30000, connectTimeoutMS=20000, socketTimeoutMS=20000, maxPoolSize=1
+        uri,
+        serverSelectionTimeoutMS=30000,
+        connectTimeoutMS=20000,
+        socketTimeoutMS=20000,
+        maxPoolSize=1,
     )
     db = client[database]
     collection = db["MetaObjects"]
@@ -87,42 +108,20 @@ async def backup_command(
             tar.add(temp_dir, arcname="metadata")
 
     client.close()
-    console.print(f"[green]Backup concluído com sucesso:[/green] [cyan]{backup_file}[/cyan]")
+    console.print(
+        f"[green]Backup concluído com sucesso:[/green] [cyan]{backup_file}[/cyan]"
+    )
 
 
 def main():
-    """Função principal para execução via linha de comando."""
-    import argparse
+    """Entry point for the CLI."""
     import asyncio
     import sys
 
-    parser = argparse.ArgumentParser(description="Gera backup dos documentos do MongoDB")
-    parser.add_argument("--host", default="localhost", help="Host do MongoDB")
-    parser.add_argument("--port", type=int, default=27017, help="Porta do MongoDB")
-    parser.add_argument("--database", required=True, help="Nome do banco de dados")
-    parser.add_argument("--output", default="backups", help="Diretório para salvar o backup")
-    parser.add_argument("--username", help="Usuário do MongoDB")
-    parser.add_argument("--password", help="Senha do MongoDB")
-    parser.add_argument("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
-    parser.add_argument("--version", help="Rótulo de versão para o arquivo de backup")
-
-    args = parser.parse_args()
-
     if sys.platform == "win32":
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
-    asyncio.run(
-        backup_command(
-            host=args.host,
-            port=args.port,
-            database=args.database,
-            output=args.output,
-            username=args.username,
-            password=args.password,
-            replicaset=args.replicaset,
-            version=args.version,
-        )
-    )
+    asyncio.run(backup_command())
 
 
 if __name__ == "__main__":

konecty_sdk_python-0.3.0/cli/pull.py

@@ -0,0 +1,265 @@
+"""Script para extrair dados do MongoDB e gerar arquivos JSON."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, TypedDict, Union, cast
+
+import black
+import click
+import inquirer
+from pymongo import MongoClient
+from rich.console import Console
+from rich.progress import Progress
+from rich.table import Table
+
+
+class DocFiles(TypedDict):
+    document: List[Path]
+    view: List[Path]
+    list: List[Path]
+    pivot: List[Path]
+    access: List[Path]
+    hook: List[Path]
+
+
+class RelatedResults(TypedDict):
+    view: List[str]
+    list: List[str]
+    pivot: List[str]
+    access: List[str]
+
+
+class MongoFilter(TypedDict, total=False):
+    document: str
+    type: str
+    name: str
+    or_conditions: List[Dict[str, str]]
+
+
+class MongoCondition(TypedDict, total=False):
+    type: str
+    name: str
+
+
+MongoQuery = Dict[str, Union[str, List[MongoCondition]]]
+
+
+DocType = Literal["document", "view", "list", "pivot", "access", "hook"]
+MetaType = Literal["view", "list", "pivot", "access"]
+
+
+console = Console()
+
+
+def format_code(name: str, code: str) -> str:
+    """Formata o código JavaScript usando black."""
+    try:
+        return black.format_str(code, mode=black.Mode())
+    except Exception as error:
+        console.print(f"[red]Erro ao formatar código {name}[/red]: {str(error)}")
+        return code
+
+
+async def write_file(file_path: str, content: str) -> None:
+    """Escreve conteúdo em um arquivo, criando diretórios se necessário."""
+    try:
+        path = Path(file_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+    except Exception as error:
+        console.print(f"[red]Erro ao escrever arquivo {file_path}[/red]: {str(error)}")
+
+
+@click.command(name="pull")
+@click.option("--host", default="localhost", help="Host do MongoDB")
+@click.option("--port", type=int, default=27017, help="Porta do MongoDB")
+@click.option("--database", default="default", help="Nome do banco de dados")
+@click.option("--output", default="metadata", help="Diretório para salvar os metadados")
+@click.option("--username", help="Usuário do MongoDB")
+@click.option("--password", help="Senha do MongoDB")
+@click.option("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
+@click.option("--document", help="Nome do documento para baixar")
+@click.option("--view", help="Nome da view específica para extrair")
+@click.option("--list", "list_param", help="Nome da lista específica para extrair")
+@click.option("--pivot", help="Nome do pivot específico para extrair")
+@click.option("--access", help="Nome do access específica para extrair")
+@click.option("--hook", help="Nome do hook específico para extrair")
+@click.option(
+    "--all",
+    "extract_all",
+    is_flag=True,
+    help="Extrair todas as collections sem perguntar",
+)
+async def pull_command(
+    host: str,
+    port: int,
+    database: str,
+    output: str,
+    username: Optional[str],
+    password: Optional[str],
+    replicaset: Optional[str],
+    document: Optional[str],
+    view: Optional[str],
+    list_param: Optional[str],
+    pivot: Optional[str],
+    access: Optional[str],
+    hook: Optional[str],
+    extract_all: bool,
+) -> None:
+    """Baixa metadados do MongoDB."""
+    output_dir = Path(output).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    uri_params = []
+    if replicaset:
+        uri_params.extend(
+            [
+                f"replicaSet={replicaset}",
+                "directConnection=false",
+                "retryWrites=true",
+                "w=majority",
+            ]
+        )
+
+    uri_suffix = f"?{'&'.join(uri_params)}" if uri_params else ""
+
+    if username and password:
+        uri = f"mongodb://{username}:{password}@{host}:{port}/admin{uri_suffix}"
+    else:
+        uri = f"mongodb://{host}:{port}{uri_suffix}"
+
+    client = MongoClient(
+        uri,
+        serverSelectionTimeoutMS=30000,
+        connectTimeoutMS=20000,
+        socketTimeoutMS=20000,
+        maxPoolSize=1,
+    )
+    db = client[database]
+    collection = db["MetaObjects"]
+
+    table = Table(title="Resultados da Extração")
+    table.add_column("Documento")
+    table.add_column("Hook")
+    table.add_column("View")
+    table.add_column("List")
+    table.add_column("Pivot")
+    table.add_column("Access")
+
+    if document is None and not extract_all:
+        document_names = list(
+            collection.find(
+                {"type": {"$in": ["composite", "document"]}}, {"name": 1}
+            ).sort("name", 1)
+        )
+        if not document_names:
+            console.print("[red]Nenhum documento encontrado.[/red]")
+            return
+
+        document_names = [doc["name"] for doc in document_names]
+        document_names.append("Todos")
+
+        questions = [
+            inquirer.List(
+                "document",
+                message="Selecione o documento para extrair",
+                choices=document_names,
+            )
+        ]
+        answers = inquirer.prompt(questions)
+        if not answers:
+            return
+        document = "all" if answers["document"] == "Todos" else answers["document"]
+    elif extract_all:
+        document = "all"
+
+    filter_query: Dict[str, Any] = {"type": {"$in": ["composite", "document"]}}
+    if document != "all":
+        filter_query["name"] = document
+
+    documents = list(collection.find(filter_query).sort("name", 1))
+
+    with Progress() as progress:
+        task = progress.add_task("[cyan]Extraindo metadados...", total=len(documents))
+
+        for doc in documents:
+            doc_path = output_dir / doc["name"]
+            doc_path.mkdir(parents=True, exist_ok=True)
+
+            # Processando hooks
+            hook_results = []
+            if "validationData" in doc:
+                await write_file(
+                    str(doc_path / "hook" / "validationData.json"),
+                    json.dumps(doc["validationData"], indent=2),
+                )
+                hook_results.append("✓ validationData")
+
+            for script_type in [
+                "scriptBeforeValidation",
+                "validationScript",
+                "scriptAfterSave",
+            ]:
+                if script_type in doc:
+                    formatted = format_code(f"{script_type}.js", doc[script_type])
+                    await write_file(
+                        str(doc_path / "hook" / f"{script_type}.js"), formatted
+                    )
+                    hook_results.append(f"✓ {script_type}")
+
+            # Processando views, lists, pivots e access
+            related_results: RelatedResults = {
+                "view": [],
+                "list": [],
+                "pivot": [],
+                "access": [],
+            }
+            for type_name, param in [
+                ("view", view),
+                ("list", list_param),
+                ("pivot", pivot),
+                ("access", access),
+            ]:
+                if param is not None:
+                    condition = {"type": type_name}
+                    if param != "all":
+                        condition["name"] = param
+                    related_metas = list(collection.find(condition).sort("_id", 1))
+
+                    for meta in related_metas:
+                        meta_type = cast(MetaType, meta["type"])
+                        if meta_type in ("view", "list", "pivot", "access"):
+                            await write_file(
+                                str(doc_path / meta_type / f"{meta['name']}.json"),
+                                json.dumps(meta, indent=2),
+                            )
+                            related_results[meta_type].append(f"✓ {meta['name']}")
+
+            table.add_row(
+                doc["name"],
+                "\n".join(hook_results),
+                "\n".join(related_results["view"]),
+                "\n".join(related_results["list"]),
+                "\n".join(related_results["pivot"]),
+                "\n".join(related_results["access"]),
+            )
+
+            progress.update(task, advance=1)
+
+    console.print(table)
+    client.close()
+
+
+def main():
+    """Entry point for the CLI."""
+    import asyncio
+    import sys
+
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+    asyncio.run(pull_command())
+
+
+if __name__ == "__main__":
+    main()

{konecty_sdk_python-0.1.0 → konecty_sdk_python-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "konecty-sdk-python"
-version = "0.1.0"
+version = "0.3.0"
 description = "Konecty SDK Python"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -32,6 +32,9 @@ dependencies = [
     "pydantic>=2.11.4",
 ]
 
+[project.scripts]
+konecty-cli = "cli:main"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

konecty_sdk_python-0.1.0/README.md

@@ -1,3 +0,0 @@
-## Konecty Python SDK
-
-> 🛠️ Work in progress

konecty_sdk_python-0.1.0/cli/__init__.py

@@ -1,7 +0,0 @@
-"""CLI tools for Konecty metadata management."""
-
-from .apply import apply_command
-from .backup import backup_command
-from .pull import pull_command
-
-__all__ = ["apply_command", "backup_command", "pull_command"]

konecty_sdk_python-0.1.0/cli/pull.py

@@ -1,262 +0,0 @@
-"""Script para extrair dados do MongoDB e gerar arquivos JSON."""
-
-import json
-from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, TypedDict, Union, cast
-
-import black
-import inquirer
-from pymongo import MongoClient
-from rich.console import Console
-from rich.progress import Progress
-from rich.table import Table
-
-
-class DocFiles(TypedDict):
-    document: List[Path]
-    view: List[Path]
-    list: List[Path]
-    pivot: List[Path]
-    access: List[Path]
-    hook: List[Path]
-
-
-class RelatedResults(TypedDict):
-    view: List[str]
-    list: List[str]
-    pivot: List[str]
-    access: List[str]
-
-
-class MongoFilter(TypedDict, total=False):
-    document: str
-    type: str
-    name: str
-    or_conditions: List[Dict[str, str]]
-
-
-class MongoCondition(TypedDict, total=False):
-    type: str
-    name: str
-
-
-MongoQuery = Dict[str, Union[str, List[MongoCondition]]]
-
-
-DocType = Literal["document", "view", "list", "pivot", "access", "hook"]
-MetaType = Literal["view", "list", "pivot", "access"]
-
-
-console = Console()
-
-
-def format_code(name: str, code: str) -> str:
-    """Formata o código JavaScript usando black."""
-    try:
-        return black.format_str(code, mode=black.Mode())
-    except Exception as error:
-        console.print(f"[red]Erro ao formatar código {name}[/red]: {str(error)}")
-        return code
-
-
-async def write_file(file_path: str, content: str) -> None:
-    """Escreve conteúdo em um arquivo, criando diretórios se necessário."""
-    try:
-        path = Path(file_path)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(content)
-    except Exception as error:
-        console.print(f"[red]Erro ao escrever arquivo {file_path}[/red]: {str(error)}")
-
-
-async def pull_command(
-    doc_parameter: Optional[str] = None,
-    host: str = "localhost",
-    port: int = 27017,
-    database: str = "default",
-    output: str = "metadata",
-    view: Optional[str] = None,
-    list_param: Optional[str] = None,
-    pivot: Optional[str] = None,
-    access: Optional[str] = None,
-    hook: Optional[str] = None,
-    username: Optional[str] = None,
-    password: Optional[str] = None,
-    replicaset: Optional[str] = None,
-    extract_all: bool = False,
-) -> None:
-    """Extrai dados do MongoDB e gera arquivos JSON."""
-    output_dir = Path(output).resolve()
-
-    uri_params = []
-    if replicaset:
-        uri_params.extend([f"replicaSet={replicaset}", "directConnection=false", "retryWrites=true", "w=majority"])
-
-    uri_suffix = f"?{'&'.join(uri_params)}" if uri_params else ""
-
-    if username and password:
-        uri = f"mongodb://{username}:{password}@{host}:{port}/admin{uri_suffix}"
-    else:
-        uri = f"mongodb://{host}:{port}{uri_suffix}"
-
-    client = MongoClient(
-        uri, serverSelectionTimeoutMS=30000, connectTimeoutMS=20000, socketTimeoutMS=20000, maxPoolSize=1
-    )
-    db = client[database]
-    collection = db["MetaObjects"]
-
-    document = doc_parameter
-
-    table = Table(title="Resultados da Extração")
-    table.add_column("Documento")
-    table.add_column("Hook")
-    table.add_column("View")
-    table.add_column("List")
-    table.add_column("Pivot")
-    table.add_column("Access")
-
-    if document is None and not extract_all:
-        document_names = list(
-            collection.find({"type": {"$in": ["composite", "document"]}}, {"name": 1}).sort("name", 1)
-        )
-        choices = [{"name": "Todos", "value": "all"}] + [
-            {"name": doc["name"], "value": doc["name"]} for doc in document_names
-        ]
-
-        questions = [
-            inquirer.List(
-                "document", message="Qual documento você precisa?", choices=[choice["name"] for choice in choices]
-            )
-        ]
-        answers = inquirer.prompt(questions)
-        if answers is None:
-            console.print("[red]Operação cancelada pelo usuário[/red]")
-            return
-        document = "all" if answers["document"] == "Todos" else answers["document"]
-    elif extract_all:
-        document = "all"
-
-    filter_query: Dict[str, Any] = {"type": {"$in": ["composite", "document"]}}
-    if document != "all":
-        filter_query["name"] = document
-
-    metas = list(collection.find(filter_query).sort("_id", 1))
-
-    with Progress() as progress:
-        task = progress.add_task("[cyan]Processando...", total=len(metas))
-
-        for doc in metas:
-            doc_path = output_dir / doc["name"]
-
-            # Processando hooks
-            hook_results = []
-            if hook or all(x is None for x in [view, list_param, pivot, access]):
-                doc_meta = doc.copy()
-                for field in ["scriptBeforeValidation", "validationData", "validationScript", "scriptAfterSave"]:
-                    doc_meta.pop(field, None)
-
-                if hook in (None, "validationData") and "validationData" in doc:
-                    await write_file(
-                        str(doc_path / "hook" / "validationData.json"), json.dumps(doc["validationData"], indent=2)
-                    )
-                    hook_results.append("✓ validationData")
-
-                for script_type in ["scriptBeforeValidation", "validationScript", "scriptAfterSave"]:
-                    if script_type in doc and (hook is None or hook == script_type):
-                        formatted = format_code(f"{script_type}.js", doc[script_type])
-                        await write_file(str(doc_path / "hook" / f"{script_type}.js"), formatted)
-                        hook_results.append(f"✓ {script_type}")
-
-                if hook is None:
-                    await write_file(str(doc_path / "document.json"), json.dumps(doc_meta, indent=2))
-
-            # Processando views, lists, pivots e access
-            related_results: RelatedResults = {"view": [], "list": [], "pivot": [], "access": []}
-            if all(x is None for x in [hook, view, list_param, pivot, access]) or any(
-                x is not None for x in [view, list_param, pivot, access]
-            ):
-                MONGO_OR = "$or"
-                meta_filter = {"document": doc["name"]}
-                meta_filter[MONGO_OR] = []
-
-                if any(x is not None for x in [view, list_param, pivot, access]):
-                    for type_name, param in [
-                        ("view", view),
-                        ("list", list_param),
-                        ("pivot", pivot),
-                        ("access", access),
-                    ]:
-                        if param is not None:
-                            condition = {"type": type_name}
-                            if param != "all":
-                                condition["name"] = param
-                            meta_filter[MONGO_OR].append(condition)
-
-                related_metas = list(collection.find(meta_filter).sort("_id", 1))
-
-                for meta in related_metas:
-                    meta_type = cast(MetaType, meta["type"])
-                    if meta_type in ("view", "list", "pivot", "access"):
-                        await write_file(str(doc_path / meta_type / f"{meta['name']}.json"), json.dumps(meta, indent=2))
-                        related_results[meta_type].append(f"✓ {meta['name']}")
-
-            table.add_row(
-                doc["name"],
-                "\n".join(hook_results),
-                "\n".join(related_results["view"]),
-                "\n".join(related_results["list"]),
-                "\n".join(related_results["pivot"]),
-                "\n".join(related_results["access"]),
-            )
-
-            progress.update(task, advance=1)
-
-    client.close()
-    console.print(f"[green]Extração concluída com sucesso do banco[/green] [cyan]{database}[/cyan]")
-    if document != "all":
-        console.print(f"[cyan]Documento: {document}[/cyan]")
-
-    console.print(table)
-
-
-def main():
-    """Função principal para execução via linha de comando."""
-    import argparse
-    import asyncio
-    import sys
-
-    parser = argparse.ArgumentParser(description="Extrai dados do MongoDB")
-    parser.add_argument("--host", default="localhost", help="Host do MongoDB")
-    parser.add_argument("--port", type=int, default=27017, help="Porta do MongoDB")
-    parser.add_argument("--database", required=True, help="Nome do banco de dados")
-    parser.add_argument("--output", default="metadata", help="Diretório de saída")
-    parser.add_argument("--view", help="Nome da view específica para extrair")
-    parser.add_argument("--list", dest="list_param", help="Nome da lista específica para extrair")
-    parser.add_argument("--pivot", help="Nome do pivot específico para extrair")
-    parser.add_argument("--access", help="Nome do access específica para extrair")
-    parser.add_argument("--hook", help="Nome do hook específico para extrair")
-    parser.add_argument("--username", help="Usuário do MongoDB")
-    parser.add_argument("--password", help="Senha do MongoDB")
-    parser.add_argument("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
-    parser.add_argument("collection", nargs="?", help="Nome da collection específica para extrair")
-    parser.add_argument("--all", action="store_true", help="Extrair todas as collections sem perguntar")
-
-    args = parser.parse_args()
-    args_dict = vars(args)
-
-    # Se collection foi especificada, usa como doc_parameter
-    if "collection" in args_dict:
-        args_dict["doc_parameter"] = args_dict.pop("collection")
-
-    # Renomeia o parâmetro all para extract_all
-    if "all" in args_dict:
-        args_dict["extract_all"] = args_dict.pop("all")
-
-    if sys.platform == "win32":
-        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-
-    asyncio.run(pull_command(**args_dict))
-
-
-if __name__ == "__main__":
-    main()