dblift 3.4.0__tar.gz → 3.4.2__tar.gz

{dblift-3.4.0 → dblift-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.4.0
+Version: 3.4.2
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{dblift-3.4.0 → dblift-3.4.2}/api/_client_operations.py

@@ -37,6 +37,19 @@ def _apply_sql_script_warning_scan(
                     result.add_warning(warning_msg)
 
 
+def _resolve_configured_schema(client: Any) -> Optional[str]:
+    """Get the actually-configured database schema from a client, if any.
+
+    Used so undo statements are qualified with the schema the client is
+    really connected to instead of a dialect-specific guess. Returns
+    ``None`` when ``client.config.database.schema`` isn't a usable string
+    (e.g. unset, or a test double without real config).
+    """
+    database = getattr(getattr(client, "config", None), "database", None)
+    schema = getattr(database, "schema", None)
+    return schema if isinstance(schema, str) and schema else None
+
+
 def generate_undo_script_operation(
     client: Any,
     *,
@@ -91,14 +104,24 @@ def generate_undo_scripts_operation(
     **kwargs: Any,
 ) -> List[GenerateUndoScriptResult]:
     """Generate many undo scripts for ``DBLiftClient.generate_undo_scripts``."""
+    from core.migration.formats import MigrationFormatDetector
+
     results: List[GenerateUndoScriptResult] = []
 
     if migration_paths is None:
         migrations_dir = (
             client._get_scripts_dir() if migrations_dir is None else Path(migrations_dir)
         )
-        pattern = "**/V*.sql" if recursive else "V*.sql"
-        migration_paths = [f for f in migrations_dir.glob(pattern) if f.is_file()]
+        # Discover versioned migration files of any supported format (not just
+        # .sql) so that non-SQL migrations (e.g. CosmosDB's Python-only
+        # migrations) still show up as per-file results below explaining why
+        # they were skipped, instead of vanishing from a SQL-only glob.
+        pattern = "**/V*" if recursive else "V*"
+        migration_paths = [
+            f
+            for f in migrations_dir.glob(pattern)
+            if f.is_file() and MigrationFormatDetector.is_migration_file(f)
+        ]
     else:
         migration_paths = [Path(p) for p in migration_paths]
 
@@ -147,13 +170,15 @@ def generate_undo_scripts_operation(
                 {"error": error_msg, "operation": "generate_undo_script"},
             )
 
+    success_count = sum(1 for r in results if r.success)
+    failure_count = sum(1 for r in results if not r.success)
     client.events.emit(
-        EventType.MIGRATION_COMPLETED,
+        EventType.MIGRATION_FAILED if failure_count > 0 else EventType.MIGRATION_COMPLETED,
         {
             "operation": "generate_undo_scripts",
             "results": results,
-            "success_count": sum(1 for r in results if r.success),
-            "failure_count": sum(1 for r in results if not r.success),
+            "success_count": success_count,
+            "failure_count": failure_count,
         },
     )
     return results
@@ -211,7 +236,11 @@ def _generate_undo_script_for_migration(
     if output_dir_path is None:
         output_dir_path = migration_path.parent
 
-    generator = UndoScriptGenerator(dialect=client.dialect, logger=client.logger)
+    generator = UndoScriptGenerator(
+        dialect=client.dialect,
+        logger=client.logger,
+        default_schema=_resolve_configured_schema(client),
+    )
     expected_undo_path = generator.get_undo_script_path_for_migration(
         migration,
         output_dir=output_dir_path,

{dblift-3.4.0 → dblift-3.4.2}/api/client.py

@@ -511,7 +511,7 @@ class DBLiftClient:
         """
         self._guard_scripts_dir_kwarg(kwargs)
         self.events.emit(
-            EventType.MIGRATION_STARTED,
+            EventType.UNDO_STARTED,
             {
                 "target_version": target_version,
                 "dry_run": dry_run,
@@ -539,7 +539,7 @@ class DBLiftClient:
 
             if result.success:
                 self.events.emit(
-                    EventType.MIGRATION_COMPLETED,
+                    EventType.UNDO_COMPLETED,
                     {
                         "result": result,
                         "operation": "undo",
@@ -547,7 +547,7 @@ class DBLiftClient:
                 )
             else:
                 self.events.emit(
-                    EventType.MIGRATION_FAILED,
+                    EventType.UNDO_FAILED,
                     {
                         "error": getattr(result, "error_message", None),
                         "operation": "undo",
@@ -557,7 +557,7 @@ class DBLiftClient:
             return result
         except Exception as e:
             self.events.emit(
-                EventType.MIGRATION_FAILED,
+                EventType.UNDO_FAILED,
                 {
                     "error": str(e),
                     "operation": "undo",
@@ -616,7 +616,10 @@ class DBLiftClient:
 
         Args:
             migration_paths: List of paths to versioned SQL migration files (V*__.sql).
-                             If None, finds all versioned SQL migrations in migrations_dir.
+                             If None, finds all versioned migrations in migrations_dir.
+                             Non-SQL migrations (e.g. Python) are included in the results
+                             with an error explaining why they were skipped, since automatic
+                             undo generation only supports SQL migrations.
             migrations_dir: Directory to search for migrations (default: configured migrations dir)
             overwrite: Whether to overwrite existing undo scripts
             recursive: Search migrations directory recursively
@@ -671,7 +674,7 @@ class DBLiftClient:
         """
         self._guard_scripts_dir_kwarg(kwargs)
         self.events.emit(
-            EventType.MIGRATION_STARTED,
+            EventType.CLEAN_STARTED,
             {
                 "operation": "clean",
                 "dry_run": dry_run,
@@ -688,18 +691,27 @@ class DBLiftClient:
                 **kwargs,
             )
 
-            self.events.emit(
-                EventType.MIGRATION_COMPLETED,
-                {
-                    "result": result,
-                    "operation": "clean",
-                },
-            )
+            if result.success:
+                self.events.emit(
+                    EventType.CLEAN_COMPLETED,
+                    {
+                        "result": result,
+                        "operation": "clean",
+                    },
+                )
+            else:
+                self.events.emit(
+                    EventType.CLEAN_FAILED,
+                    {
+                        "error": getattr(result, "error_message", None),
+                        "operation": "clean",
+                    },
+                )
 
             return result
         except Exception as e:
             self.events.emit(
-                EventType.MIGRATION_FAILED,
+                EventType.CLEAN_FAILED,
                 {
                     "error": str(e),
                     "operation": "clean",
@@ -725,7 +737,7 @@ class DBLiftClient:
             BaselineResult with baseline details
         """
         self.events.emit(
-            EventType.MIGRATION_STARTED,
+            EventType.BASELINE_STARTED,
             {
                 "operation": "baseline",
                 "version": version,
@@ -739,18 +751,27 @@ class DBLiftClient:
                 **kwargs,
             )
 
-            self.events.emit(
-                EventType.MIGRATION_COMPLETED,
-                {
-                    "result": result,
-                    "operation": "baseline",
-                },
-            )
+            if result.success:
+                self.events.emit(
+                    EventType.BASELINE_COMPLETED,
+                    {
+                        "result": result,
+                        "operation": "baseline",
+                    },
+                )
+            else:
+                self.events.emit(
+                    EventType.BASELINE_FAILED,
+                    {
+                        "error": getattr(result, "error_message", None),
+                        "operation": "baseline",
+                    },
+                )
 
             return result
         except Exception as e:
             self.events.emit(
-                EventType.MIGRATION_FAILED,
+                EventType.BASELINE_FAILED,
                 {
                     "error": str(e),
                     "operation": "baseline",
@@ -781,7 +802,7 @@ class DBLiftClient:
         """
         self._guard_scripts_dir_kwarg(kwargs)
         self.events.emit(
-            EventType.MIGRATION_STARTED,
+            EventType.REPAIR_STARTED,
             {
                 "operation": "repair",
                 "dry_run": dry_run,
@@ -798,18 +819,27 @@ class DBLiftClient:
                 **kwargs,
             )
 
-            self.events.emit(
-                EventType.MIGRATION_COMPLETED,
-                {
-                    "result": result,
-                    "operation": "repair",
-                },
-            )
+            if result.success:
+                self.events.emit(
+                    EventType.REPAIR_COMPLETED,
+                    {
+                        "result": result,
+                        "operation": "repair",
+                    },
+                )
+            else:
+                self.events.emit(
+                    EventType.REPAIR_FAILED,
+                    {
+                        "error": getattr(result, "error_message", None),
+                        "operation": "repair",
+                    },
+                )
 
             return result
         except Exception as e:
             self.events.emit(
-                EventType.MIGRATION_FAILED,
+                EventType.REPAIR_FAILED,
                 {
                     "error": str(e),
                     "operation": "repair",
@@ -883,6 +913,30 @@ class DBLiftClient:
     plan = _make_premium_stub_method("plan")
     preflight = _make_premium_stub_method("preflight")
 
+    @classmethod
+    def _resolve_factory_client_cls(cls) -> type:
+        """The class ``from_config``/``from_config_file``/``from_sqlalchemy``
+        should construct.
+
+        Called on the base ``DBLiftClient`` class, this consults the same
+        ``dblift.client`` seam the CLI already uses
+        (``core.seams.client_factory.resolve_client_class``) so a
+        tier-provided subclass is returned when one is registered — the
+        documented ``from api.client import DBLiftClient`` entry point then
+        behaves like the CLI instead of always constructing the OSS class
+        (issue #753). Called on any other class — a caller already
+        constructing a specific subclass directly — the seam is not
+        consulted, so that explicit choice is never overridden.
+        """
+        if cls is not DBLiftClient:
+            return cls
+        # Imported here (not at module top) so tests can monkeypatch
+        # core.seams.client_factory.resolve_client_class per-call; a top-level
+        # `from ... import` would bind the function once and ignore later patches.
+        from core.seams.client_factory import resolve_client_class
+
+        return resolve_client_class()
+
     @classmethod
     def from_config(
         cls,
@@ -913,7 +967,9 @@ class DBLiftClient:
             kwargs["migrations_dir"] = migrations_dir
         return cast(
             Self,
-            client_from_config(config, logger, client_cls=cls, **kwargs),
+            client_from_config(
+                config, logger, client_cls=cls._resolve_factory_client_cls(), **kwargs
+            ),
         )
 
     @classmethod
@@ -939,7 +995,9 @@ class DBLiftClient:
             overrides["environment"] = environment
         return cast(
             Self,
-            client_from_config_file(config_path, logger, client_cls=cls, **overrides),
+            client_from_config_file(
+                config_path, logger, client_cls=cls._resolve_factory_client_cls(), **overrides
+            ),
         )
 
     @classmethod
@@ -983,7 +1041,7 @@ class DBLiftClient:
                 log_file,
                 connection=connection,
                 config=config,
-                client_cls=cls,
+                client_cls=cls._resolve_factory_client_cls(),
                 **kwargs,
             ),
         )

{dblift-3.4.0 → dblift-3.4.2}/cli/_config_helpers.py

@@ -178,7 +178,7 @@ def _build_args_namespace(
             args.dry_run = False
             args.log_dir = "logs"
             args.log_format = "text"
-            args.log_level = "info"
+            args.log_level = None
             args.log_file = None
             args.database_url = None
             args.database_username = None
@@ -458,7 +458,13 @@ def _configure_logging(
         "warn": LogLevel.WARN,
         "error": LogLevel.ERROR,
     }
-    log_level = _LOG_LEVEL_MAP.get(args.log_level, LogLevel.INFO)
+    # ``config.log_level`` is the already-merged value (file -> env -> CLI
+    # precedence applied in config.dblift_config.load_config); prefer it over
+    # the raw CLI namespace, which only reflects an explicit --log-level and
+    # otherwise carries no signal about file/env config. Fall back to
+    # args.log_level when the merged config has none set.
+    effective_log_level = getattr(config, "log_level", None) or args.log_level
+    log_level = _LOG_LEVEL_MAP.get(effective_log_level, LogLevel.INFO)
     # ``--quiet`` raises the *console* threshold to NOTICE so info/debug
     # lines disappear from the terminal while NOTICE (success
     # confirmations, "Command completed"), WARN, and ERROR still show
@@ -557,6 +563,13 @@ def _resolve_scripts_directories(
             parser.error(f"Migration scripts directory not found: {args.scripts_list[0]}")
 
         config.migrations.directory = str(scripts_dir)
+        # --scripts fully replaces any config-file migrations.directories
+        # list. Without this, get_directory_configs() (called later by
+        # api._client_factory.client_from_config(), the CLI's actual path
+        # to resolving the primary migrations dir) would keep preferring the
+        # stale plural list over the singular `directory` set above, silently
+        # dropping this first --scripts value.
+        config.migrations.directories = []
 
         if len(args.scripts_list) > 1:
             for scripts_path in args.scripts_list[1:]:

{dblift-3.4.0 → dblift-3.4.2}/cli/_parser_setup.py

@@ -444,10 +444,15 @@ def create_parser(
     parser.add_argument("--log-format", default="text", help="Log format (text, json, html)")
     parser.add_argument(
         "--log-level",
-        default="info",
+        # No default here: a non-None default is indistinguishable from an
+        # explicit choice once merged with config-file/env values (CLI > env >
+        # file precedence), so it would always win and silently discard
+        # DBLIFT_LOG_LEVEL / a config file's log_level. _configure_logging()
+        # falls back to LogLevel.INFO when nothing sets a level.
+        default=None,
         type=str.lower,
         choices=["debug", "info", "warn", "error"],
-        help="Log level (case-insensitive)",
+        help="Log level (case-insensitive, default: info)",
     )
     parser.add_argument("--log-file", help="Log file name")
     parser.add_argument(

{dblift-3.4.0 → dblift-3.4.2}/cli/db_utils.py

@@ -7,12 +7,14 @@ import traceback
 from pathlib import Path
 from typing import Any, Dict, List
 
+import yaml
+
 from api._cli_support import (
     ProviderRegistry,
     get_provider_display_url,
 )
 from cli._output import CommandOutput, from_args
-from config.dblift_config import load_config
+from config.dblift_config import DbliftConfig, load_config, unrecognized_top_level_keys
 from core.logger import DbliftLogger, LogFormat
 from core.utils.url_masking import mask_database_url
 from db.error import format_connection_error
@@ -87,6 +89,7 @@ def validate_config(args: argparse.Namespace) -> int:
             except (FileNotFoundError, RuntimeError) as load_err:
                 out.error(f"Error: {load_err}")
                 return 1
+            _warn_if_unrecognized_top_level_keys(config_file, out)
         else:
             # Batch-6 BUG-04: without ``--config`` and without ``--db-url`` (or
             # the ``DBLIFT_DB_URL`` env var), ``load_config`` returns a config
@@ -122,6 +125,30 @@ def validate_config(args: argparse.Namespace) -> int:
         return 1
 
 
+def _warn_if_unrecognized_top_level_keys(config_file: str, out: CommandOutput) -> None:
+    """Emit a stderr warning when the config file has an unrecognized top-level key.
+
+    Config file loading is permissive by construction: an unknown top-level
+    key (e.g. a typo like ``migratoins_dir``) is silently dropped rather than
+    rejected, so the command runs as if the key wasn't there. ``validate-config``
+    is the natural place to surface that, since checking config correctness is
+    its whole purpose. Re-reading the file here is best-effort — any error is
+    swallowed since ``load_config`` already loaded it successfully.
+    """
+    try:
+        raw_data = DbliftConfig.load_config_data_from_yaml(config_file)
+    except (OSError, yaml.YAMLError):
+        return
+    unknown = unrecognized_top_level_keys(raw_data)
+    if not unknown:
+        return
+    keys = ", ".join(unknown)
+    out.error(
+        f"Warning: unrecognized configuration key(s): {keys}. "
+        f"Check for typos — unrecognized keys are ignored."
+    )
+
+
 _CREDENTIALLESS_TEST_TYPES = frozenset({"dummy"})
 
 

{dblift-3.4.0 → dblift-3.4.2}/cli/main.py

@@ -220,6 +220,32 @@ def _resolve_core_version() -> Optional[str]:
         return None
 
 
+def _resolve_manifest_version() -> Optional[str]:
+    """Return the ``version`` field of a ``DISTRIBUTION-MANIFEST.json`` sitting
+    next to the running entry point, if one is present.
+
+    An archive/frozen distribution ships this file at its root, stamped at
+    build time with the version of the code it actually bundles. Unlike
+    ``importlib.metadata``, it cannot be shadowed by an unrelated distribution
+    that happens to be installed elsewhere on the host — so when present, it
+    is the most authoritative source for "what version is this". A real
+    ``pip install`` never ships this file, so this is a no-op there.
+    """
+    import json
+
+    manifest_file = _project_root / "DISTRIBUTION-MANIFEST.json"
+    try:
+        with open(manifest_file, "r", encoding="utf-8") as f:
+            manifest = json.load(f)
+        if isinstance(manifest, dict):
+            version = manifest.get("version")
+            if isinstance(version, str) and version:
+                return version
+    except (OSError, ValueError):
+        pass
+    return None
+
+
 def _format_version() -> str:
     """Render the ``--version`` output.
 
@@ -231,11 +257,30 @@ def _format_version() -> str:
     is present, list every component so a bare number is never ambiguous. In a
     plain OSS install only the core is present, so the output stays a single
     ``dblift version X`` line — unchanged from before.
+
+    An archive/frozen distribution's ``DISTRIBUTION-MANIFEST.json``, when
+    present, overrides the headline: it is stamped at build time and immune to
+    whatever unrelated ``dblift``/``dblift-pro``/``dblift-enterprise``
+    metadata happens to be installed on the host running it.
+
+    The breakdown lines apply that same preference at the component level: a
+    directly-importable package's own ``__version__`` attribute is tried
+    before ``importlib.metadata.version``, for consistency with how the
+    headline already avoids stale host-installed metadata.
     """
+    import importlib
     from importlib.metadata import PackageNotFoundError
     from importlib.metadata import version as _version
 
     def _get(dist: str) -> Optional[str]:
+        try:
+            module = importlib.import_module(dist.replace("-", "_"))
+            module_version = getattr(module, "__version__", None)
+            if isinstance(module_version, str) and module_version:
+                return module_version
+        except Exception:
+            # A broken install shouldn't crash --version; fall back to metadata.
+            pass
         try:
             return _version(dist)
         except PackageNotFoundError:
@@ -245,8 +290,9 @@ def _format_version() -> str:
     pro = _get("dblift-pro")
     enterprise = _get("dblift-enterprise")
 
-    # Headline = most-derived installed tier (the product actually running).
-    product = enterprise or pro or core
+    # Headline = manifest version (bundled distribution) if present, else the
+    # most-derived installed tier (the product actually running).
+    product = _resolve_manifest_version() or enterprise or pro or core
     lines = [f"dblift version {product}"]
     # Component manifest only when a paid tier is present; OSS stays one line.
     if pro or enterprise:
@@ -519,6 +565,28 @@ def _apply_configured_output_format(ctx: _CliContext) -> None:
         ctx.args.format = output_format
 
 
+def _effective_scripts_dir_for_log(client: Any, fallback: Optional[Path]) -> Any:
+    """Return the directory ``client`` will actually scan, for debug logging.
+
+    ``_resolve_scripts_directories`` computes ``scripts_dir`` locally
+    (resolving relative paths against the config file's parent directory),
+    but that value is never handed to the client — ``_build_command_client``
+    builds it straight from ``ctx.config``, which re-resolves the migrations
+    directory independently (relative paths are resolved against the
+    current working directory at scan time). The two can disagree, so the
+    debug line must reflect the client's own resolution, not the local one.
+    Falls back to the locally-computed value for clients without
+    ``_get_scripts_dir`` (e.g. config-only stand-ins).
+    """
+    get_scripts_dir = getattr(client, "_get_scripts_dir", None)
+    if not callable(get_scripts_dir):
+        return fallback
+    try:
+        return get_scripts_dir().resolve()
+    except (OSError, RuntimeError, TypeError):
+        return fallback
+
+
 def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
     """Phase 4: build full workflow context and run the command loop.
 
@@ -532,7 +600,7 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
     )
 
     client = _build_command_client(ctx)
-    ctx.log.debug(f"scripts_dir: {scripts_dir}")
+    ctx.log.debug(f"scripts_dir: {_effective_scripts_dir_for_log(client, scripts_dir)}")
     ctx.log.debug(
         f"config.migrations.directories: {getattr(ctx.config.migrations, 'directories', None)}"
     )

{dblift-3.4.0 → dblift-3.4.2}/config/dblift_config.py

@@ -4,7 +4,7 @@ import os
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Mapping, Optional, Tuple, Type, Union, cast
+from typing import Any, Dict, FrozenSet, List, Mapping, Optional, Tuple, Type, Union, cast
 
 import yaml
 
@@ -44,6 +44,56 @@ _ENVIRONMENT_SECTION_KEYS: Tuple[str, ...] = ("environments", "resolve")
 #: ``--config``, it selects configuration rather than being configuration.
 DEFAULT_ENV_SELECTOR_VAR = "DBLIFT_ENV"
 
+# Every top-level key ``DbliftConfig.from_dict`` (and its supporting helpers)
+# actually reads. File loading is permissive by construction — an unrecognized
+# key is silently dropped rather than rejected — so this set exists to let
+# ``db validate-config`` flag likely typos (e.g. ``migratoins_dir``) that would
+# otherwise run unnoticed. Keep in sync with the ``data.get(...)`` reads in
+# :meth:`DbliftConfig.from_dict`.
+KNOWN_TOP_LEVEL_CONFIG_KEYS: FrozenSet[str] = frozenset(
+    (
+        "database",
+        "migrations",
+        "migrations_dir",  # deprecated alias for migrations.directory
+        "logging",
+        "log_dir",
+        "log_file",
+        "log_format",
+        "log_level",
+        "baseline_version",
+        "target_version",
+        "dry_run",
+        "undo",
+        "installed_by",
+        "extra_params",
+        "tags",
+        "exclude_tags",
+        "versions",
+        "exclude_versions",
+        "mark_as_executed",
+        "strict_mode",
+        "clean_disabled",
+        "placeholders",
+        "history_table",
+        "snapshot_table",
+        "max_snapshots",
+        "secrets",
+    )
+    + _ENVIRONMENT_SECTION_KEYS
+    + _PAID_RAW_CONFIG_KEYS
+)
+
+
+def unrecognized_top_level_keys(data: Dict[str, Any]) -> List[str]:
+    """Return the top-level keys in *data* that the config schema doesn't recognize, sorted.
+
+    Used by ``db validate-config`` to warn about likely typos instead of
+    silently ignoring the key, as plain config loading does.
+    """
+    if not isinstance(data, dict):
+        return []
+    return sorted(key for key in data if key not in KNOWN_TOP_LEVEL_CONFIG_KEYS)
+
 
 # ``validate-sql`` only needs a dialect-typed DbliftConfig; connection is never opened.
 # Placeholder database URLs satisfy :meth:`DbliftConfig.validate_complete_data` and are never
@@ -336,8 +386,13 @@ class DirectoryConfig:
         if isinstance(data, str):
             return cls(path=data, recursive=True)
         elif isinstance(data, dict):
+            # Accept 'directory' as an alias for 'path' — it mirrors the
+            # top-level migrations.directory field name, so it's a natural
+            # key for users to reach for here. Without this, an entry keyed
+            # on 'directory' silently resolves to an empty path and finds
+            # nothing.
             return cls(
-                path=data.get("path", ""),
+                path=data.get("path", data.get("directory", "")),
                 recursive=data.get("recursive", True),
             )
         else:

{dblift-3.4.0 → dblift-3.4.2}/core/logger/log.py

@@ -499,6 +499,16 @@ class FileLog(AbstractLog):
             # If no extension in the pattern and no format placeholder, add the extension
             elif "." not in log_file_name.split("/")[-1]:
                 log_file_name += f".{extension}"
+
+            # A pattern that already has its own directory component (e.g.
+            # "logs/info.html" from --log-file) is a path meant to be
+            # resolved relative to the current working directory — joining
+            # it onto log_dir would double-nest it when log_dir happens to
+            # share a name with that directory. Only a bare filename (no
+            # directory component) nests under log_dir.
+            log_file_path = Path(log_file_name)
+            if log_file_path.parent != Path("."):
+                return log_file_path
         else:
             # Use default naming convention
             log_file_name = (