baucli 1.0.1__py3-none-any.whl

baucli/sync.py

@@ -0,0 +1,846 @@
+"""BAUCLI — Smart Sync engine.
+
+Orchestrates: check server status → decide FULL/DELTA → extract → batch → send.
+Supports multi-db with --db flag.
+"""
+
+import hashlib
+import re
+from typing import Optional
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeElapsedColumn, MofNCompleteColumn
+from rich.table import Table as RichTable
+
+from baucli.config import get_database, get_db_password, load_config
+from baucli.api import BauApi, BauApiError
+from baucli.db import BauConnectionError
+
+console = Console()
+
+BATCH_SIZE = 50  # Objects per API call (body_text CLOB has no 32KB limit)
+
+
+# ---------------------------------------------------------------------------
+# Hash helpers — espelham a logica de BAUCTX.FNC_BAU_STRIP_DUP_DDL_HEAD +
+# RAWTOHEX(DBMS_CRYPTO.HASH(SOURCE, HASH_SH256)). Usados pelo --dry-run para
+# comparar hashes locais com os do servidor SEM enviar nada.
+# ---------------------------------------------------------------------------
+def _strip_dup_ddl_head(source: str, obj_type: str) -> str:
+    """Remove o prefixo 'CREATE OR REPLACE <TYPE> [schema.]name\\n' duplicado
+    quando a linha seguinte ja comeca com '<TYPE> name'. Espelha
+    BAUCTX.FNC_BAU_STRIP_DUP_DDL_HEAD."""
+    if not source or not obj_type:
+        return source
+    pattern = (
+        r'^(CREATE\s+OR\s+REPLACE\s+' + re.escape(obj_type) +
+        r'\s+[^\n]+\n)\s*' + re.escape(obj_type) +
+        r'\s+("?[A-Za-z0-9_$#]+"?\.)?"?[A-Za-z0-9_$#]+"?\s+'
+    )
+    return re.sub(pattern, r'\1', source, count=1, flags=re.IGNORECASE)
+
+
+def _compute_source_hash(source: str, obj_type: str) -> str:
+    """SHA-256 uppercase do source normalizado (mesma logica do servidor)."""
+    if not source:
+        return ""
+    normalized = _strip_dup_ddl_head(source, obj_type or "")
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest().upper()
+
+
+def show_sync_preview(api: "BauApi", schema: str, objects: list, tables: list) -> dict:
+    """Compara hashes locais (calculados aqui) com os do servidor BAU.
+    Renderiza tabela rich agrupada por status (NEW / MODIFIED / UNCHANGED).
+    Retorna dict com contadores."""
+    # Fetch BAU side hashes (PL/SQL + tables)
+    try:
+        bau_obj = api.get_source_hashes(schema)
+    except Exception as e:
+        console.print(f"    [red]Erro ao buscar hashes do BAU: {e}[/red]")
+        bau_obj = {"items": []}
+    try:
+        bau_tbl = api.get_table_hashes(schema)
+    except Exception as e:
+        console.print(f"    [yellow]Aviso: hash de tabelas indisponível ({e})[/yellow]")
+        bau_tbl = {"items": []}
+
+    # Index by (type, name) — server returns items list
+    bau_obj_idx = {(it.get("type", "").upper(), it.get("name", "").upper()): it
+                   for it in bau_obj.get("items", []) or []}
+    bau_tbl_idx = {(it.get("name", "").upper()): it
+                   for it in bau_tbl.get("items", []) or []}
+
+    rows = []
+    counts = {"NEW": 0, "MODIFIED": 0, "UNCHANGED": 0, "TOTAL": 0}
+
+    # PL/SQL objects
+    for obj in objects:
+        name = (obj.get("name") or "").upper()
+        otype = (obj.get("type") or "").upper()
+        # Skip subprograms — server SOURCE table only tracks root objects
+        if obj.get("subprogram_name") or obj.get("parent"):
+            continue
+        source = obj.get("source") or ""
+        local_hash = _compute_source_hash(source, otype)
+        bau_item = bau_obj_idx.get((otype, name))
+        bau_hash = (bau_item or {}).get("hash", "") if bau_item else ""
+
+        if not bau_hash:
+            status = "NEW"
+        elif local_hash and local_hash == bau_hash:
+            status = "UNCHANGED"
+        else:
+            status = "MODIFIED"
+        rows.append({
+            "kind": "PL/SQL", "name": name, "type": otype,
+            "status": status, "local": local_hash[:16], "bau": bau_hash[:16],
+        })
+        counts[status] += 1
+        counts["TOTAL"] += 1
+
+    # Tables — no source_hash; rely on the table structure hash from server.
+    # Local side does not compute that here (it's a column-signature SHA at the
+    # server). We list each table as NEW (not in BAU) or UNCHANGED (in BAU)
+    # without per-byte comparison.
+    for tbl in tables:
+        name = (tbl.get("name") or "").upper()
+        bau_item = bau_tbl_idx.get(name)
+        status = "NEW" if not bau_item else "UNCHANGED"
+        rows.append({
+            "kind": "TABLE", "name": name, "type": "TABLE",
+            "status": status, "local": "(table)", "bau": "(table)",
+        })
+        counts[status] += 1
+        counts["TOTAL"] += 1
+
+    if not rows:
+        console.print("    [dim]Nenhum objeto extraído para comparar.[/dim]")
+        return counts
+
+    # Render
+    style_map = {
+        "NEW": "[green]NEW[/green]",
+        "MODIFIED": "[yellow]MODIFIED[/yellow]",
+        "UNCHANGED": "[dim]UNCHANGED[/dim]",
+    }
+    table = RichTable(
+        title=f"Sync preview — schema {schema} ({counts['TOTAL']} item(s))",
+        show_lines=False)
+    table.add_column("Kind", style="cyan")
+    table.add_column("Type")
+    table.add_column("Name")
+    table.add_column("Status")
+    table.add_column("Local hash")
+    table.add_column("BAU hash")
+    # Order: MODIFIED first, then NEW, then UNCHANGED
+    order = {"MODIFIED": 0, "NEW": 1, "UNCHANGED": 2}
+    rows.sort(key=lambda r: (order.get(r["status"], 9), r["kind"], r["name"]))
+    for r in rows:
+        table.add_row(r["kind"], r["type"], r["name"], style_map[r["status"]],
+                      r["local"], r["bau"])
+    console.print(table)
+
+    summary = (
+        f"    [bold]Preview:[/bold] "
+        f"[green]{counts['NEW']} NEW[/green]"
+        f"  •  [yellow]{counts['MODIFIED']} MODIFIED[/yellow]"
+        f"  •  [dim]{counts['UNCHANGED']} UNCHANGED[/dim]"
+        f"  •  total {counts['TOTAL']}"
+    )
+    console.print(summary)
+    return counts
+
+
+def _resolve_wallet_password(name: str) -> str:
+    """Wallet password (thin-mode ewallet.pem) via env var then keyring.
+
+    Never persisted in config.json — env BAUCLI_WALLET_PASSWORD wins, else the
+    keyring entry '<db>::wallet' set by `baucli db add --wallet`.
+    """
+    import os
+    pw = os.environ.get("BAUCLI_WALLET_PASSWORD")
+    if pw:
+        return pw
+    if name:
+        try:
+            from baucli.config import get_db_password
+            return get_db_password(f"{name}::wallet")
+        except Exception:
+            return None
+    return None
+
+
+def get_extractor(db_config: dict, password: str, name: str = None,
+                  wallet_password: str = None):
+    """Factory: return the right extractor based on engine.
+
+    name (optional) is the DB alias — used to resolve the Oracle Wallet password
+    from the keyring when db_config carries a wallet_path. wallet_password, when
+    given, overrides that resolution (used during `connect` before the password
+    is persisted).
+    """
+    engine = db_config.get("engine", "").lower()
+
+    if engine == "oracle":
+        from baucli.db.oracle import OracleExtractor
+        wallet_path = db_config.get("wallet_path")
+        wpw = wallet_password if wallet_password is not None else (
+            _resolve_wallet_password(name) if wallet_path else None)
+        return OracleExtractor(
+            host=db_config.get("host"),
+            port=db_config.get("port"),
+            user=db_config["user"],
+            password=password,
+            service=db_config.get("service"),
+            wallet_path=wallet_path,
+            wallet_password=wpw,
+        )
+    elif engine == "postgresql":
+        from baucli.db.postgresql import PostgreSQLExtractor
+        return PostgreSQLExtractor(
+            host=db_config["host"],
+            port=db_config["port"],
+            user=db_config["user"],
+            password=password,
+            database=db_config.get("database"),
+        )
+    elif engine == "mssql":
+        from baucli.db.mssql import MSSQLExtractor
+        return MSSQLExtractor(
+            host=db_config["host"],
+            port=db_config["port"],
+            user=db_config["user"],
+            password=password,
+            database=db_config.get("database"),
+        )
+    elif engine == "mysql":
+        from baucli.db.mysql import MySQLExtractor
+        return MySQLExtractor(
+            host=db_config["host"],
+            port=db_config["port"],
+            user=db_config["user"],
+            password=password,
+            database=db_config.get("database"),
+        )
+    else:
+        raise ValueError(f"Unsupported database engine: {engine}")
+
+
+def get_sync_recommendation(api: BauApi, schema: str) -> dict:
+    """Ask the BAU Server for sync recommendation.
+
+    Returns dict with: recommendation (FULL/DELTA), last_sync, delta_days, sync_max_days
+    """
+    try:
+        status = api.sync_status(schema)
+        # Handle wrapped response
+        if 'text' in status and 'recommendation' not in status:
+            import json
+            try:
+                status = json.loads(status['text'])
+            except Exception:
+                pass
+        return status
+    except BauApiError:
+        # Server unavailable or endpoint missing — default to FULL
+        return {"recommendation": "FULL", "last_sync": None, "delta_days": None, "sync_max_days": 30}
+
+
+PARALLEL_THRESHOLD = 1000  # Default: parallelize if total objects+tables >= this
+PARALLEL_WORKERS = 3       # Default thread count (from server config)
+
+
+def sync_database(db_name: str, db_config: dict, api: BauApi,
+                  schemas: list = None, force_full: bool = False,
+                  days_override: int = None, sync_filter: str = "all",
+                  parallel: bool = None, verbose: bool = False,
+                  overwrite_undocumented: bool = False,
+                  object_name: str = None, table_name: str = None,
+                  dry_run: bool = False, scope_names: dict = None,
+                  rowcount: bool = True) -> dict:
+    """Sync a single database: check status -> extract -> send to API.
+
+    Args:
+        db_name: Database alias
+        db_config: Database config dict
+        api: BauApi client
+        schemas: Override schema list
+        force_full: If True, always do full extraction
+        days_override: If set, extract only objects modified in last N days
+        sync_filter: 'all' (default), 'objects' (PL/SQL only), 'tables' (tables only)
+        parallel: True=force parallel, False=force sequential, None=auto (threshold-based)
+        verbose: Verbose output
+
+    Returns summary dict with counts.
+    """
+    password = get_db_password(db_name)
+    if not password:
+        import getpass
+        password = getpass.getpass(f"  Password for '{db_name}': ")
+        if not password:
+            console.print(f"  [red]No password provided.[/red]")
+            return {"status": "error", "message": "No password"}
+
+    engine = db_config.get("engine", "oracle").upper()
+    target_schemas = schemas or db_config.get("schemas", [])
+    if not target_schemas:
+        console.print(f"  [yellow]No schemas configured for '{db_name}'. Add schemas to config.[/yellow]")
+        return {"status": "error", "message": "No schemas"}
+
+    extractor = get_extractor(db_config, password, db_name)
+    total_objects = 0
+    total_tables = 0
+
+    try:
+        extractor.connect()
+        info = extractor.test_connection()
+        live_db_version = info.get("version") or db_config.get("db_version")
+        if verbose:
+            console.print(f"  Connected: {live_db_version or '?'}")
+
+        for schema in target_schemas:
+            # === Step 1: Decide FULL or DELTA ===
+            since_date = None
+            mode = "FULL"
+
+            # PostgreSQL: always FULL (no native DDL tracking, delta unreliable)
+            pg_forced_full = engine in ("postgresql", "postgres") and not force_full and days_override is None
+
+            if force_full:
+                mode = "FULL"
+                console.print(f"  [cyan]{schema}[/cyan] — [bold]FULL[/bold] (forced)")
+            elif pg_forced_full:
+                mode = "FULL"
+                console.print(f"  [cyan]{schema}[/cyan] — [bold]FULL[/bold] (PG: no DDL tracking, hash-based dedup)")
+            elif days_override is not None:
+                mode = "DELTA"
+                from datetime import datetime, timedelta
+                since_dt = datetime.now() - timedelta(days=days_override)
+                since_date = since_dt.strftime("%Y-%m-%dT%H:%M:%S")
+                console.print(f"  [cyan]{schema}[/cyan] — [bold]DELTA[/bold] (last {days_override} days)")
+            else:
+                # Ask server for recommendation
+                rec = get_sync_recommendation(api, schema)
+                mode = rec.get("recommendation", "FULL")
+                last_sync = rec.get("last_sync")
+                delta_days = rec.get("delta_days")
+                sync_max = rec.get("sync_max_days", 30)
+
+                if mode == "DELTA" and last_sync:
+                    since_date = last_sync
+                    console.print(f"  [cyan]{schema}[/cyan] — [bold]DELTA[/bold] (since {last_sync[:10]}, {delta_days}d ago, max={sync_max}d)")
+                else:
+                    if last_sync is None:
+                        console.print(f"  [cyan]{schema}[/cyan] — [bold]FULL[/bold] (first sync)")
+                    else:
+                        console.print(f"  [cyan]{schema}[/cyan] — [bold]FULL[/bold] (last sync {delta_days}d ago > max {sync_max}d)")
+
+            # === Step 2: Extract ===
+            objects = []
+            tables = []
+
+            # Scope pushdown: with a scope set, extract ONLY the scoped names.
+            # The Oracle extractor honors a collection in name_filter (IN list
+            # on the catalog query); other engines ignore it and fall back to
+            # the post-extraction filter below. Without this, a scoped sync of
+            # a 6000-table ERP still extracted everything before discarding.
+            eff_object_name = object_name
+            eff_table_name = table_name
+            if scope_names is not None:
+                if not eff_object_name:
+                    eff_object_name = sorted(scope_names.get("plsql") or set())
+                if not eff_table_name:
+                    eff_table_name = sorted(scope_names.get("table") or set())
+
+            # Determine if parallel extraction should be used
+            use_parallel = False
+            par_workers = PARALLEL_WORKERS
+            if parallel is True:
+                use_parallel = True
+            elif parallel is False:
+                use_parallel = False
+            else:
+                try:
+                    rec = get_sync_recommendation(api, schema)
+                    threshold = int(rec.get("parallel_threshold", PARALLEL_THRESHOLD))
+                    par_enabled = rec.get("parallel_enabled", "Y")
+                    par_workers = int(rec.get("parallel_workers", PARALLEL_WORKERS))
+                    total_hint = int(rec.get("objects_count", 0)) + int(rec.get("tables_count", 0))
+                    if par_enabled == "Y":
+                        if mode == "FULL":
+                            use_parallel = True
+                        else:
+                            use_parallel = total_hint >= threshold
+                except Exception:
+                    use_parallel = mode == "FULL"
+
+            if use_parallel and sync_filter == "all":
+                from concurrent.futures import ThreadPoolExecutor
+                import threading, time
+
+                # Quick count before extracting (1 if name filter set, else schema count)
+                cnt_obj = -1
+                cnt_tbl = -1
+                try:
+                    cnt_obj = (1 if object_name
+                               else len(eff_object_name) if isinstance(eff_object_name, list)
+                               else extractor.count_objects(schema))
+                    cnt_tbl = (1 if table_name
+                               else len(eff_table_name) if isinstance(eff_table_name, list)
+                               else extractor.count_tables(schema))
+                    if cnt_obj >= 0 and cnt_tbl >= 0:
+                        console.print(f"    Scope: [cyan]{cnt_obj}[/cyan] objects + [cyan]{cnt_tbl}[/cyan] tables/views")
+                except Exception:
+                    pass
+
+                status_lock = threading.Lock()
+                obj_status = ["starting..."]
+                tbl_status = ["starting..."]
+                obj_times = []
+                tbl_times = []
+
+                def _obj_progress(current, total, name):
+                    with status_lock:
+                        eta = ""
+                        if len(obj_times) >= 5:
+                            avg = sum(obj_times) / len(obj_times)
+                            remaining = total - current
+                            eta_s = int(remaining * avg)
+                            eta = f" ETA {eta_s//60}m{eta_s%60:02d}s" if eta_s >= 60 else f" ETA {eta_s}s"
+                        obj_status[0] = f"{current}/{total} {name[:40]}{eta}"
+
+                def _tbl_progress(current, total, name):
+                    with status_lock:
+                        eta = ""
+                        if len(tbl_times) >= 5:
+                            avg = sum(tbl_times) / len(tbl_times)
+                            remaining = total - current
+                            eta_s = int(remaining * avg)
+                            eta = f" ETA {eta_s//60}m{eta_s%60:02d}s" if eta_s >= 60 else f" ETA {eta_s}s"
+                        tbl_status[0] = f"{current}/{total} {name[:40]}{eta}"
+
+                def _extract_objects():
+                    last_t = [time.time()]
+                    def _cb(c, t, n):
+                        now = time.time()
+                        dt = now - last_t[0]
+                        last_t[0] = now
+                        if c > 1:
+                            obj_times.append(dt)
+                        _obj_progress(c, t, n)
+                    # Own connection for thread safety
+                    ext2 = get_extractor(db_config, password, db_name)
+                    ext2.connect()
+                    with status_lock:
+                        obj_status[0] = "connected, querying..."
+                    try:
+                        r = ext2.extract_objects(schema, since_date=since_date, on_progress=_cb,
+                                                 name_filter=eff_object_name)
+                        with status_lock:
+                            obj_status[0] = f"[green]done[/green] ({len(r)})"
+                        return r
+                    finally:
+                        ext2.disconnect()
+
+                def _extract_tables():
+                    last_t = [time.time()]
+                    def _cb(c, t, n):
+                        now = time.time()
+                        dt = now - last_t[0]
+                        last_t[0] = now
+                        if c > 1:
+                            tbl_times.append(dt)
+                        _tbl_progress(c, t, n)
+                    # Own connection for thread safety
+                    ext2 = get_extractor(db_config, password, db_name)
+                    ext2.connect()
+                    with status_lock:
+                        tbl_status[0] = "connected, querying..."
+                    try:
+                        r = ext2.extract_tables(schema, since_date=since_date, on_progress=_cb,
+                                                name_filter=eff_table_name)
+                        with status_lock:
+                            tbl_status[0] = f"[green]done[/green] ({len(r)})"
+                        return r
+                    finally:
+                        ext2.disconnect()
+
+                with Progress(
+                    SpinnerColumn(), TextColumn("{task.description}"), TimeElapsedColumn(),
+                    console=console, transient=False,
+                ) as progress:
+                    tid_obj = progress.add_task("    PL/SQL:  extracting...", total=None)
+                    tid_tbl = progress.add_task("    Tables:  extracting...", total=None)
+
+                    with ThreadPoolExecutor(max_workers=min(par_workers, 2)) as pool:
+                        fut_obj = pool.submit(_extract_objects)
+                        fut_tbl = pool.submit(_extract_tables)
+
+                        while not (fut_obj.done() and fut_tbl.done()):
+                            with status_lock:
+                                progress.update(tid_obj, description=f"    PL/SQL:  {obj_status[0]}")
+                                progress.update(tid_tbl, description=f"    Tables:  {tbl_status[0]}")
+                            progress.refresh()
+                            time.sleep(0.3)
+
+                        # Final update
+                        with status_lock:
+                            progress.update(tid_obj, description=f"    PL/SQL:  {obj_status[0]}")
+                            progress.update(tid_tbl, description=f"    Tables:  {tbl_status[0]}")
+
+                try:
+                    objects = fut_obj.result()
+                except Exception as e:
+                    console.print(f"    [red]Objects error: {e}[/red]")
+                try:
+                    tables = fut_tbl.result()
+                except Exception as e:
+                    console.print(f"    [red]Tables error: {e}[/red]")
+
+            else:
+                # Sequential — show count + progress per item (1 if name filter set)
+                cnt_obj = -1
+                cnt_tbl = -1
+                try:
+                    if sync_filter in ("all", "objects"):
+                        cnt_obj = (1 if object_name
+                                   else len(eff_object_name) if isinstance(eff_object_name, list)
+                                   else extractor.count_objects(schema))
+                    if sync_filter in ("all", "tables"):
+                        cnt_tbl = (1 if table_name
+                                   else len(eff_table_name) if isinstance(eff_table_name, list)
+                                   else extractor.count_tables(schema))
+                    parts = []
+                    if cnt_obj >= 0: parts.append(f"[cyan]{cnt_obj}[/cyan] objects")
+                    if cnt_tbl >= 0: parts.append(f"[cyan]{cnt_tbl}[/cyan] tables/views")
+                    if parts:
+                        console.print(f"    Scope: {' + '.join(parts)}")
+                except Exception:
+                    pass
+
+                import time as _time
+                with Progress(
+                    SpinnerColumn(), TextColumn("{task.description}"), TimeElapsedColumn(),
+                    console=console, transient=False,
+                ) as progress:
+                    if sync_filter in ("all", "objects"):
+                        total_est = cnt_obj if cnt_obj > 0 else None
+                        tid = progress.add_task(f"    PL/SQL: extracting...", total=total_est)
+                        item_times = []
+                        last_t = [_time.time()]
+                        def _obj_cb(c, t, n):
+                            now = _time.time()
+                            dt = now - last_t[0]
+                            last_t[0] = now
+                            if c > 1:
+                                item_times.append(dt)
+                            eta = ""
+                            if len(item_times) >= 5:
+                                avg = sum(item_times) / len(item_times)
+                                rem = t - c
+                                eta_s = int(rem * avg)
+                                eta = f" ETA {eta_s//60}m{eta_s%60:02d}s" if eta_s >= 60 else f" ETA {eta_s}s"
+                            progress.update(tid, completed=c, description=f"    PL/SQL: {c}/{t} {n[:40]}{eta}")
+                        objects = extractor.extract_objects(schema, since_date=since_date, on_progress=_obj_cb,
+                                                            name_filter=eff_object_name)
+                        progress.update(tid, description=f"    PL/SQL: [green]done[/green] ({len(objects)})", completed=total_est or len(objects))
+
+                    if sync_filter in ("all", "tables"):
+                        total_est = cnt_tbl if cnt_tbl > 0 else None
+                        tid = progress.add_task(f"    Tables: extracting...", total=total_est)
+                        item_times = []
+                        last_t = [_time.time()]
+                        def _tbl_cb(c, t, n):
+                            now = _time.time()
+                            dt = now - last_t[0]
+                            last_t[0] = now
+                            if c > 1:
+                                item_times.append(dt)
+                            eta = ""
+                            if len(item_times) >= 5:
+                                avg = sum(item_times) / len(item_times)
+                                rem = t - c
+                                eta_s = int(rem * avg)
+                                eta = f" ETA {eta_s//60}m{eta_s%60:02d}s" if eta_s >= 60 else f" ETA {eta_s}s"
+                            progress.update(tid, completed=c, description=f"    Tables: {c}/{t} {n[:40]}{eta}")
+                        tables = extractor.extract_tables(schema, since_date=since_date, on_progress=_tbl_cb,
+                                                          name_filter=eff_table_name)
+                        progress.update(tid, description=f"    Tables: [green]done[/green] ({len(tables)})", completed=total_est or len(tables))
+
+            mode_label = "[green]parallel[/green]" if use_parallel and sync_filter == "all" else "sequential"
+
+            # === Scope filter: keep only objects listed in the scope set ===
+            # Client-side recorte — the whole motivation of scope sets: a
+            # migration project touches ~10 of an ERP's hundreds of objects, so
+            # never extract/send the rest (saves catalog noise + AI tokens).
+            if scope_names is not None:
+                scope_pl  = scope_names.get("plsql") or set()
+                scope_tab = scope_names.get("table") or set()
+                before_o, before_t = len(objects), len(tables)
+                objects = [o for o in objects
+                           if (o.get("name") or "").upper() in scope_pl]
+                tables  = [t for t in tables
+                           if (t.get("name") or "").upper() in scope_tab]
+                console.print(
+                    f"    [magenta]scope[/magenta]: {len(objects)}/{before_o} PL/SQL + "
+                    f"{len(tables)}/{before_t} tabelas dentro do recorte "
+                    f"(demais ignorados)")
+
+            all_items = objects + tables
+
+            if not all_items:
+                label = "modified " if mode == "DELTA" else ""
+                console.print(f"    No {label}objects found in {schema}")
+                # Hint when --object was used but the name might actually be a table.
+                if object_name and not table_name:
+                    console.print(f"    [dim]Hint: '{object_name}' is not a PL/SQL object. "
+                                  f"If it's a table, try: baucli sync --table {object_name}[/dim]")
+                elif table_name and not object_name:
+                    console.print(f"    [dim]Hint: '{table_name}' is not a table/view. "
+                                  f"If it's a PL/SQL object, try: baucli sync --object {table_name}[/dim]")
+                continue
+
+            obj_count = len(objects)
+            tbl_count = len(tables)
+            console.print(f"    Found: {obj_count} PL/SQL + {tbl_count} tables ({mode_label})")
+
+            # === Dry-run: preview hash diff sem enviar ao servidor ===
+            if dry_run:
+                console.print(f"    [bold yellow]DRY-RUN[/bold yellow] — nenhum dado sera enviado ao servidor.")
+                preview = show_sync_preview(api, schema, objects, tables)
+                total_objects += obj_count
+                total_tables += tbl_count
+                continue  # pula o envio para este schema
+
+            # === Step 3: Send to API in batches ===
+            synced_obj = 0
+            synced_tbl = 0
+            synced_src = 0
+            rebaselined  = 0   # post-deploy idempotent re-baselines on the server
+            server_errors = 0
+            error_details: dict[str, str] = {}   # {object_name: server SQLERRM}
+            total_batches = (len(all_items) + BATCH_SIZE - 1) // BATCH_SIZE
+            import time as _time
+            batch_times = []    # seconds per batch for ETA calculation
+            SAMPLE_SIZE = 4     # batches to sample before showing ETA
+
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[bold]{task.description}"),
+                BarColumn(bar_width=30),
+                MofNCompleteColumn(),
+                TextColumn("•"),
+                TimeElapsedColumn(),
+                console=console,
+            ) as progress:
+                task = progress.add_task(
+                    f"    Syncing {schema}", total=total_batches)
+
+                consecutive_errors = 0
+                MAX_CONSECUTIVE_ERRORS = 3
+                MAX_RETRIES = 2
+
+                for i in range(0, len(all_items), BATCH_SIZE):
+                    batch = all_items[i:i + BATCH_SIZE]
+                    batch_num = (i // BATCH_SIZE) + 1
+                    batch_ok = False
+                    t0 = _time.time()
+
+                    for attempt in range(MAX_RETRIES + 1):
+                        try:
+                            result = api.sync_batch(
+                                schema=schema,
+                                db_engine=engine,
+                                objects=batch,
+                                db_version=live_db_version,
+                                overwrite_undocumented=overwrite_undocumented,
+                                db_name=db_name,
+                            )
+                            synced_obj += result.get('objects_synced', 0)
+                            synced_tbl += result.get('tables_synced', 0)
+                            synced_src += result.get('sources_stored', 0)
+                            rebaselined += result.get('sources_rebaselined', 0)
+                            # Server-side per-object failures: PROCESS_SYNC_BATCH
+                            # swallows them into `errors` + `error_details` and
+                            # still returns 200. If we don't surface this, the
+                            # operator sees "Synced: 0 objects" with no clue why
+                            # while side-effects (e.g. PRE_DOCUMENTED flips) did
+                            # happen inside the silent EXCEPTION blocks.
+                            batch_errs = int(result.get('errors', 0) or 0)
+                            if batch_errs:
+                                server_errors += batch_errs
+                                details = result.get('error_details') or {}
+                                if isinstance(details, dict):
+                                    error_details.update({k: str(v) for k, v in details.items()})
+                            batch_ok = True
+                            consecutive_errors = 0
+                            break
+                        except BauApiError as e:
+                            err_msg = str(e)
+                            if attempt < MAX_RETRIES:
+                                wait = 2 ** attempt
+                                progress.update(task, description=f"    Retry {attempt+1}/{MAX_RETRIES} in {wait}s...")
+                                _time.sleep(wait)
+                            else:
+                                console.print(f"    [red]Batch {batch_num} failed after {MAX_RETRIES+1} attempts: {err_msg}[/red]")
+
+                    if batch_ok:
+                        elapsed = _time.time() - t0
+                        batch_times.append(elapsed)
+
+                    if not batch_ok:
+                        consecutive_errors += 1
+                        if consecutive_errors >= MAX_CONSECUTIVE_ERRORS:
+                            console.print(f"    [red]Circuit breaker: {MAX_CONSECUTIVE_ERRORS} consecutive failures. Stopping sync.[/red]")
+                            console.print(f"    [yellow]Synced so far: {synced_obj} objects, {synced_tbl} tables. Resume with: baucli sync --db {db_name}[/yellow]")
+                            break
+
+                    # Build description with ETA
+                    desc = f"    Syncing {schema} ({synced_obj} obj, {synced_tbl} tbl)"
+                    if len(batch_times) >= SAMPLE_SIZE:
+                        avg_batch = sum(batch_times) / len(batch_times)
+                        remaining = total_batches - batch_num
+                        eta_sec = int(remaining * avg_batch)
+                        if eta_sec >= 60:
+                            desc += f" • ETA {eta_sec // 60}m{eta_sec % 60:02d}s"
+                        elif eta_sec > 0:
+                            desc += f" • ETA {eta_sec}s"
+
+                    progress.update(task, advance=1, description=desc)
+
+            # Show timing summary
+            if batch_times:
+                total_time = sum(batch_times)
+                avg_per_item = total_time / max(len(all_items), 1)
+                items_per_sec = len(all_items) / max(total_time, 0.01)
+                rebaseline_str = (
+                    f" [cyan](re-baselined {rebaselined})[/cyan]"
+                    if rebaselined else ""
+                )
+                console.print(
+                    f"    [green]Synced: {synced_obj} objects, {synced_tbl} tables, "
+                    f"{synced_src} sources[/green]{rebaseline_str}"
+                    f" [dim]({total_time:.1f}s, {avg_per_item:.2f}s/item, {items_per_sec:.0f} items/s)[/dim]"
+                )
+                if server_errors:
+                    # The server replied 200 but logged per-object failures.
+                    # Show the count plus a short sample so the operator can
+                    # see what actually broke without digging the server log.
+                    console.print(
+                        f"    [yellow]Server reported {server_errors} per-object error(s) "
+                        f"during PROCESS_SYNC_BATCH.[/yellow]"
+                    )
+                    for i, (obj_name, err) in enumerate(list(error_details.items())[:5]):
+                        console.print(f"      [yellow]•[/yellow] {obj_name}: [dim]{err}[/dim]")
+                    if len(error_details) > 5:
+                        console.print(f"      [dim]... and {len(error_details) - 5} more[/dim]")
+            # === Dependency graph (Fase 2): extrai as dependências do dicionário
+            # do CLIENTE (ALL/DBA_DEPENDENCIES, escopo intra-schema) e envia numa
+            # chamada dedicada (objects=[]). O servidor persiste em BAU_DEP_RAW e
+            # o grafo é reconstruído por PKG_BAU_DEPGRAPH — o BAU nunca lê o
+            # dicionário local. Só Oracle, modo objetos, fora do single-object.
+            if engine.upper() == "ORACLE" and sync_filter in ("all", "objects") \
+                    and not object_name and hasattr(extractor, "extract_dependencies"):
+                try:
+                    deps = extractor.extract_dependencies(schema)
+                    api.sync_batch(schema=schema, db_engine=engine, objects=[],
+                                   dependencies=deps, db_version=live_db_version,
+                                   db_name=db_name)
+                    console.print(f"    [green]Dependencies: {len(deps)} edge(s) sent[/green]")
+                except Exception as e:
+                    console.print(f"    [yellow]Dependencies skip: {e}[/yellow]")
+
+            # === DOCSEQ: sequences do schema (chamada dedicada, objects=[]) ===
+            # O servidor persiste os metadados fisicos (SYNC_FROM_JSON) e roda
+            # PKG_BAU_DOCSEQ.DISCOVER — que liga sequence->tabela a partir dos
+            # defaults/triggers ja sincronizados. Todos os engines com extractor
+            # que expoe extract_sequences (MySQL devolve [] — usa AUTO_INCREMENT).
+            # Fora do single-object/single-table e do recorte por scope.
+            if sync_filter in ("all", "tables") and not object_name and not table_name \
+                    and scope_names is None and hasattr(extractor, "extract_sequences"):
+                try:
+                    # Spinner durante a coleta + envio (feedback consistente com
+                    # PL/SQL/Tables): mostra o avanco e a contagem de sequences.
+                    with console.status("    Sequences: extracting...", spinner="dots"):
+                        seqs = extractor.extract_sequences(schema)
+                    if seqs:
+                        with console.status(f"    Sequences: sending {len(seqs)}...", spinner="dots"):
+                            api.sync_batch(schema=schema, db_engine=engine, objects=[],
+                                           sequences=seqs, db_version=live_db_version,
+                                           db_name=db_name)
+                        console.print(f"    Sequences: [green]done[/green] ({len(seqs)} collected & sent)")
+                    else:
+                        console.print(f"    Sequences: [dim]none[/dim]")
+                except Exception as e:
+                    console.print(f"    [yellow]Sequences skip: {e}[/yellow]")
+
+            total_objects += obj_count
+            total_tables += tbl_count
+
+        # Baseline de num_rows (a "ideia" do tamanho das tabelas) capturada em
+        # TODO sync, com origem DEV (o baucli normalmente roda no ambiente de
+        # dev). Best-effort — nunca derruba o sync. No servidor, um profile PROD
+        # é "grudento" e não é sobrescrito por este baseline de DEV.
+        if rowcount and not dry_run:
+            # Scope pushdown: com scope set, o snapshot de num_rows cobre SO as
+            # tabelas do recorte (sem ele, um ERP de milhares de tabelas ia
+            # inteiro para o /profile/ingest a cada sync).
+            _rc_filter = None
+            if scope_names is not None:
+                _rc_filter = sorted(scope_names.get("table") or set())
+            for _rc_schema in target_schemas:
+                try:
+                    if _rc_filter is not None:
+                        _rc = extractor.extract_row_counts(_rc_schema, name_filter=_rc_filter)
+                    else:
+                        _rc = extractor.extract_row_counts(_rc_schema)
+                    api.profile_ingest(_rc)
+                    console.print(f"    Row counts: [green]done[/green] "
+                                  f"({len(_rc.get('tables', []))} tables, source=DEV"
+                                  f"{', recorte' if _rc_filter is not None else ''})")
+                except Exception as e:
+                    if verbose:
+                        console.print(f"    [dim]row-counts skip ({_rc_schema}): {e}[/dim]")
+
+    except BauConnectionError as e:
+        # Expected failure mode — banco fora do ar, credencial inválida, etc.
+        # Mostra só a mensagem amigável + hint. Sem traceback no fluxo normal.
+        console.print(f"  [red]✗ {e.message}[/red]")
+        if e.hint:
+            console.print(f"  [yellow]→ {e.hint}[/yellow]")
+        if verbose and e.cause is not None:
+            import traceback
+            console.print(f"  [dim]{''.join(traceback.format_exception(type(e.cause), e.cause, e.cause.__traceback__))}[/dim]")
+        return {"status": "error", "message": e.message, "error_type": "connection"}
+    except Exception as e:
+        import traceback
+        console.print(f"  [red]Connection error: {e}[/red]")
+        console.print(f"  [dim]{traceback.format_exc()}[/dim]")
+        return {"status": "error", "message": str(e)}
+    finally:
+        extractor.disconnect()
+
+    return {
+        "status": "ok",
+        "db_name": db_name,
+        "engine": engine,
+        "objects": total_objects,
+        "tables": total_tables,
+        "schemas": target_schemas,
+    }
+
+
+def sync_all(api: BauApi, force_full: bool = False,
+             days_override: int = None, sync_filter: str = "all",
+             verbose: bool = False,
+             overwrite_undocumented: bool = False) -> list:
+    """Sync all configured databases."""
+    cfg = load_config()
+    results = []
+    for name, db in cfg.get("databases", {}).items():
+        console.print(f"\n[bold]{name}[/bold] ({db.get('engine', '?')})")
+        result = sync_database(name, db, api, force_full=force_full,
+                               days_override=days_override, sync_filter=sync_filter,
+                               verbose=verbose,
+                               overwrite_undocumented=overwrite_undocumented)
+        results.append(result)
+    return results