dblift 3.3.4__tar.gz → 3.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.3.4
+Version: 3.4.0
 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.3.4 → dblift-3.4.0}/api/client.py

@@ -39,6 +39,8 @@ from core.logger.results import (
     ValidateResult,
 )
 from core.migration.executor.migration_executor import MigrationExecutor
+from core.premium_manifest import PREMIUM_COMMANDS, UPGRADE_URL, render_upsell
+from core.seams.capabilities import CapabilityDeniedError
 from core.seams.event_listeners import attach_registered_listeners
 from core.seams.feature_loading import load_feature_extensions
 from db.base_provider import BaseProvider
@@ -48,6 +50,42 @@ __all__ = ["DBLiftClient"]
 
 _F = TypeVar("_F", bound=Callable[..., Any])
 
+# Paid-tier commands that have a corresponding OSS-visible DBLiftClient
+# method name (issue #753). Keyed by ``api_method`` so
+# ``_make_premium_stub_method`` can look up the right upsell text per stub.
+_PREMIUM_COMMANDS_BY_API_METHOD = {
+    cmd.api_method: cmd for cmd in PREMIUM_COMMANDS if cmd.api_method is not None
+}
+
+
+def _make_premium_stub_method(api_method_name: str) -> Callable[..., Any]:
+    """Build a paid-tier stub method for the OSS ``DBLiftClient``.
+
+    Mirrors the CLI's ``_make_premium_stub_handler``
+    (``cli/_command_handlers.py``): rather than the method being entirely
+    absent (a bare ``AttributeError`` on call), it exists, accepts
+    whatever arguments a paid caller would pass, and raises
+    ``CapabilityDeniedError`` with the same upsell message the CLI shows
+    for the equivalent command. Not decorated with ``@_with_client_emitter``
+    — it never runs an operation, so there is nothing to bind an emitter
+    around (see ``EXPECTED_DECORATED_OPERATIONS`` in
+    ``tests/unit/api/test_public_api_surface.py``).
+    """
+    cmd = _PREMIUM_COMMANDS_BY_API_METHOD[api_method_name]
+
+    def _stub(self: "DBLiftClient", *args: Any, **kwargs: Any) -> Any:
+        raise CapabilityDeniedError(render_upsell(cmd))
+
+    _stub.__name__ = api_method_name
+    _stub.__doc__ = (
+        f"Paid-tier stub: '{cmd.name}' is a dblift {cmd.edition} command, "
+        f"not available in the open-source edition.\n\n"
+        f"Raises:\n"
+        f"    CapabilityDeniedError: always, with an upgrade message. "
+        f"See {UPGRADE_URL}."
+    )
+    return _stub
+
 
 def _with_client_emitter(method: _F) -> _F:
     """Bind ``self.events`` as the active emitter for the duration of *method*.
@@ -259,6 +297,7 @@ class DBLiftClient:
                 "dry_run": dry_run,
                 "show_sql": show_sql,
                 "tags": tags,
+                "dialect": getattr(self, "dialect", None),
             },
         )
 
@@ -294,6 +333,7 @@ class DBLiftClient:
                         "provider": self.provider,
                         "history_manager": self.executor.history_manager,
                         "log": self.logger,
+                        "dialect": getattr(self, "dialect", None),
                     },
                 )
             else:
@@ -302,6 +342,7 @@ class DBLiftClient:
                     {
                         "error": getattr(result, "error_message", None),
                         "target_version": target_version,
+                        "dialect": getattr(self, "dialect", None),
                     },
                 )
 
@@ -312,6 +353,7 @@ class DBLiftClient:
                 {
                     "error": str(e),
                     "target_version": target_version,
+                    "dialect": getattr(self, "dialect", None),
                 },
             )
             raise
@@ -406,7 +448,7 @@ class DBLiftClient:
             ValidateResult with validation status
         """
         self._guard_scripts_dir_kwarg(kwargs)
-        self.events.emit(EventType.VALIDATION_STARTED, {})
+        self.events.emit(EventType.VALIDATION_STARTED, {"dialect": getattr(self, "dialect", None)})
 
         try:
             result = self.executor.validate(
@@ -421,11 +463,17 @@ class DBLiftClient:
                 **kwargs,
             )
 
-            self.events.emit(EventType.VALIDATION_COMPLETED, {"result": result})
+            self.events.emit(
+                EventType.VALIDATION_COMPLETED,
+                {"result": result, "dialect": getattr(self, "dialect", None)},
+            )
 
             return result
         except Exception as e:
-            self.events.emit(EventType.VALIDATION_FAILED, {"error": str(e)})
+            self.events.emit(
+                EventType.VALIDATION_FAILED,
+                {"error": str(e), "dialect": getattr(self, "dialect", None)},
+            )
             raise
 
     @_with_client_emitter
@@ -823,6 +871,18 @@ class DBLiftClient:
             )
             raise
 
+    # Paid-tier stubs (issue #753): visible on the OSS class so
+    # ``hasattr``/``dir()`` finds them, mirroring the CLI's premium command
+    # stubs. Calling any of these raises ``CapabilityDeniedError`` with an
+    # upsell message instead of a bare ``AttributeError``. Deliberately not
+    # decorated with ``@_with_client_emitter`` — see
+    # ``_make_premium_stub_method`` above.
+    diff = _make_premium_stub_method("diff")
+    export_schema = _make_premium_stub_method("export_schema")
+    snapshot = _make_premium_stub_method("snapshot")
+    plan = _make_premium_stub_method("plan")
+    preflight = _make_premium_stub_method("preflight")
+
     @classmethod
     def from_config(
         cls,

{dblift-3.3.4 → dblift-3.4.0}/cli/_command_handlers.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
+from cli._constants import EXIT_LICENSE_REQUIRED
 from cli.extensions import load_command_handlers, load_terminal_commands
 from cli.handlers._shared import (  # noqa: F401
     _MIGRATION_FILENAME_RE,
@@ -23,6 +24,7 @@ from cli.handlers.repair import _handle_repair
 from cli.handlers.undo import _handle_undo
 from cli.handlers.validate import _handle_validate
 from cli.premium_manifest import PremiumCommand, premium_stub_index, render_upsell
+from core.seams.capabilities import CapabilityDeniedError
 from core.seams.tier_resolver import resolve_tier
 
 _COMMAND_HANDLERS: Dict[str, Callable[[CliCommandContext], Tuple[bool, Any]]] = {
@@ -104,7 +106,14 @@ def execute_single_command(
         # pure-OSS install no resolver is registered and this is ``None``.
         license_tier=resolve_tier(args),
     )
-    return handler(ctx)
+    try:
+        return handler(ctx)
+    except CapabilityDeniedError as e:
+        # Capability rejections map to the same exit code as premium stubs so
+        # scripts/CI can branch on entitlement without parsing stderr.
+        message = str(e).strip() or "This command requires a license that is not available."
+        log.error(message)
+        raise SystemExit(EXIT_LICENSE_REQUIRED) from e
 
 
 def _validate_migrate_options(cmd_args: Any, parser: Any) -> None:

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

@@ -45,7 +45,6 @@ _SUBCOMMAND_BOOLEAN_FLAGS = frozenset(
         "--show-sql",
         "--rehearse-rollback",
         "--skip-replay",
-        "--skip-validation",
         "--skip-validate-sql",
         "--split-by-type",
         "--strict",

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

@@ -252,10 +252,6 @@ def _add_diff_and_target_options(
     migrate_parser.add_argument("--target-version", help="Target version to migrate to")
     undo_parser.add_argument("--target-version", help="Target version to roll back to")
     validate_parser.add_argument("--target-version", help="Validate migrations up to this version")
-    # Validate specific options
-    validate_parser.add_argument(
-        "--skip-validation", action="store_true", help="Skip validation checks"
-    )
     # Migrate specific options
     migrate_parser.add_argument(
         "--validate-only",
@@ -340,21 +336,51 @@ def create_parser(
     exit_on_error: bool = True, suppress_errors: bool = False
 ) -> argparse.ArgumentParser:
     """Create and configure the argument parser for DBLift CLI."""
+    # Shared parent for the 4 db-connection flags. It is attached both to the
+    # root parser (so `dblift --db-url ... migrate` keeps working) and to the
+    # migrate/info/validate/undo subparsers (so the flags are documented in
+    # their --help output, not just the root's). ``default=argparse.SUPPRESS``
+    # is required for that dual attachment: argparse's subparser dispatch
+    # (``_SubParsersAction.__call__``) always parses the subcommand's
+    # remaining args into a *fresh* namespace and then copies every one of its
+    # dests onto the outer namespace — so a subparser-local default of ``None``
+    # would silently overwrite a value already parsed at the root level
+    # (e.g. `dblift --db-url X migrate` with no --db-url after "migrate").
+    # SUPPRESS keeps the dest off the subnamespace entirely when the flag
+    # isn't repeated after the subcommand, so the root-parsed value survives.
+    #
+    # Side effect: because this same parent is used on the root parser too,
+    # ``database_url``/``database_username``/``database_password``/
+    # ``database_schema`` may be entirely ABSENT from ``args`` (not merely
+    # ``None``) for ANY subcommand — not just migrate/info/validate/undo —
+    # whenever the flag isn't passed anywhere on the command line. Any new
+    # code reading these must use ``hasattr``/``getattr(..., None)`` (as
+    # ``cli/_config_helpers.py`` already does); a bare ``args.database_url``
+    # will raise ``AttributeError`` when unset. See
+    # tests/unit/cli/test_parser_invariants.py::
+    # test_db_flags_absent_from_namespace_when_unset_for_non_db_subcommand.
     db_parent = argparse.ArgumentParser(add_help=False)
-    db_parent.add_argument("--db-url", dest="database_url", help="Database URL")
-    db_parent.add_argument("--db-username", dest="database_username", help="Database username")
-    db_parent.add_argument("--db-password", dest="database_password", help="Database password")
-    db_parent.add_argument("--db-schema", dest="database_schema", help="Database schema")
-    # Hidden copy for the root parser: flags are parsed globally but shown in
-    # subcommand --help only.
-    db_parent_hidden = argparse.ArgumentParser(add_help=False)
-    db_parent_hidden.add_argument("--db-url", dest="database_url", help=argparse.SUPPRESS)
-    db_parent_hidden.add_argument("--db-username", dest="database_username", help=argparse.SUPPRESS)
-    db_parent_hidden.add_argument("--db-password", dest="database_password", help=argparse.SUPPRESS)
-    db_parent_hidden.add_argument("--db-schema", dest="database_schema", help=argparse.SUPPRESS)
+    db_parent.add_argument(
+        "--db-url", dest="database_url", default=argparse.SUPPRESS, help="Database URL"
+    )
+    db_parent.add_argument(
+        "--db-username",
+        dest="database_username",
+        default=argparse.SUPPRESS,
+        help="Database username",
+    )
+    db_parent.add_argument(
+        "--db-password",
+        dest="database_password",
+        default=argparse.SUPPRESS,
+        help="Database password",
+    )
+    db_parent.add_argument(
+        "--db-schema", dest="database_schema", default=argparse.SUPPRESS, help="Database schema"
+    )
     parser_kwargs: Dict[str, Any] = {
         "description": "dblift: Database migration tool",
-        "parents": [db_parent_hidden],
+        "parents": [db_parent],
     }
     if not exit_on_error:
         parser_kwargs["exit_on_error"] = False
@@ -454,22 +480,22 @@ def create_parser(
     migrate_parser = subparsers.add_parser(
         "migrate",
         help="Apply migrations",
-        parents=[_history, _strict, _filter],
+        parents=[_history, _strict, _filter, db_parent],
     )
     info_parser = subparsers.add_parser(
         "info",
         help="Show migration information",
-        parents=[_history, _strict, _filter],
+        parents=[_history, _strict, _filter, db_parent],
     )
     validate_parser = subparsers.add_parser(
         "validate",
         help="Validate migration scripts",
-        parents=[_history, _strict, _filter],
+        parents=[_history, _strict, _filter, db_parent],
     )
     undo_parser = subparsers.add_parser(
         "undo",
         help="Rollback migrations",
-        parents=[_history, _strict, _filter],
+        parents=[_history, _strict, _filter, db_parent],
     )
     clean_parser = subparsers.add_parser(
         "clean",

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

@@ -259,96 +259,96 @@ def check_connection(args: argparse.Namespace) -> int:
         logger = DbliftLogger(
             logfile_dir=log_dir, format=_log_format, log_file_pattern=_log_file_pattern
         )
-
-        # Create config from arguments
         try:
-            config = load_config(getattr(args, "config", None), args)
-
-            # Check if we have enough information to connect.
-            # SQLite can use a file path, not a server/URL.
-            # CosmosDB uses account_endpoint, not url/server.
-            _db_type_lower = (config.database.type or "").lower()
-            _has_path = getattr(config.database, "path", None) or getattr(
-                config.database, "database", None
-            )
-            _quirks = ProviderRegistry.get_quirks(_db_type_lower)
-            _url_optional_for_path = _quirks.url_optional_when_file_path_given
-            _has_connection_identifier = _quirks.has_connection_identifier(config.database)
-            _has_endpoint = getattr(config.database, "account_endpoint", None)
-            if (
-                not config.database.url
-                and not (_url_optional_for_path and _has_path)
-                and not _has_endpoint
-                and (not config.database.type or not _has_connection_identifier)
-            ):
-                error_message = (
-                    "Missing required connection parameters. Either provide --db-url or --config."
+            # Create config from arguments
+            try:
+                config = load_config(getattr(args, "config", None), args)
+
+                # Check if we have enough information to connect.
+                # SQLite can use a file path, not a server/URL.
+                # CosmosDB uses account_endpoint, not url/server.
+                _db_type_lower = (config.database.type or "").lower()
+                _has_path = getattr(config.database, "path", None) or getattr(
+                    config.database, "database", None
                 )
+                _quirks = ProviderRegistry.get_quirks(_db_type_lower)
+                _url_optional_for_path = _quirks.url_optional_when_file_path_given
+                _has_connection_identifier = _quirks.has_connection_identifier(config.database)
+                _has_endpoint = getattr(config.database, "account_endpoint", None)
+                if (
+                    not config.database.url
+                    and not (_url_optional_for_path and _has_path)
+                    and not _has_endpoint
+                    and (not config.database.type or not _has_connection_identifier)
+                ):
+                    error_message = "Missing required connection parameters. Either provide --db-url or --config."
+                    out.error(error_message)
+                    results["error"] = error_message
+                    print_connection_results(results, out)
+                    return 1
+
+                results["connection_info"]["config_source"] = "Created from provided parameters"
+            except Exception as e:
+                out.error(f"Error creating configuration: {str(e)}")
+                results["error"] = str(e)
+                print_connection_results(results, out)
+                return 1
+
+            # Validate database type
+            if not config.database.type:
+                error_message = "Missing database type. Please provide --db-type or a configuration with database type."
                 out.error(error_message)
                 results["error"] = error_message
                 print_connection_results(results, out)
                 return 1
 
-            results["connection_info"]["config_source"] = "Created from provided parameters"
-        except Exception as e:
-            out.error(f"Error creating configuration: {str(e)}")
-            results["error"] = str(e)
-            print_connection_results(results, out)
-            return 1
+            db_type = config.database.type.lower()
 
-        # Validate database type
-        if not config.database.type:
-            error_message = "Missing database type. Please provide --db-type or a configuration with database type."
-            out.error(error_message)
-            results["error"] = error_message
-            print_connection_results(results, out)
-            return 1
-
-        db_type = config.database.type.lower()
+            # Create database provider via registry (DIP — no concrete plugin imports)
+            try:
+                provider: Any = ProviderRegistry.create_provider(config, logger)
+            except ValueError as e:
+                results["error"] = str(e)
+                print_connection_results(results, out)
+                return 1
 
-        # Create database provider via registry (DIP — no concrete plugin imports)
-        try:
-            provider: Any = ProviderRegistry.create_provider(config, logger)
-        except ValueError as e:
-            results["error"] = str(e)
-            print_connection_results(results, out)
-            return 1
+            # Test connection. Format known driver errors as a one-line message so the CLI doesn't
+            # dump a Python traceback to stderr on e.g. connection refused / auth failure.
+            try:
+                provider.create_connection()
+            except Exception as connection_error:
+                friendly = _format_connection_error(connection_error, db_type)
+                out.error(friendly)
+                results["error"] = friendly
+                print_connection_results(results, out)
+                if getattr(args, "log_level", "info") == "debug":
+                    traceback.print_exc()
+                return 1
 
-        # Test connection. Format known driver errors as a one-line message so the CLI doesn't
-        # dump a Python traceback to stderr on e.g. connection refused / auth failure.
-        try:
-            provider.create_connection()
-        except Exception as connection_error:
-            friendly = _format_connection_error(connection_error, db_type)
-            out.error(friendly)
-            results["error"] = friendly
+            try:
+                # Get database version and URL before updating results
+                version = provider.get_database_version()
+                database_url = get_provider_display_url(provider, config) or config.database.url
+
+                # Update results atomically once all operations succeed
+                results["success"] = True
+                results["connection_info"]["database_url"] = (
+                    mask_database_url(database_url) if database_url else database_url
+                )
+                results["connection_info"]["db_type"] = db_type
+                schema = getattr(config.database, "schema", None)
+                if schema:
+                    results["connection_info"]["schema"] = schema
+                results["database_info"]["version"] = version
+            finally:
+                # Close connection even if get_database_version/display URL lookup raises
+                provider.close()
+
+            # Print results in requested format
             print_connection_results(results, out)
-            if getattr(args, "log_level", "info") == "debug":
-                traceback.print_exc()
-            return 1
-
-        try:
-            # Get database version and URL before updating results
-            version = provider.get_database_version()
-            database_url = get_provider_display_url(provider, config) or config.database.url
-
-            # Update results atomically once all operations succeed
-            results["success"] = True
-            results["connection_info"]["database_url"] = (
-                mask_database_url(database_url) if database_url else database_url
-            )
-            results["connection_info"]["db_type"] = db_type
-            schema = getattr(config.database, "schema", None)
-            if schema:
-                results["connection_info"]["schema"] = schema
-            results["database_info"]["version"] = version
+            return 0
         finally:
-            # Close connection even if get_database_version/display URL lookup raises
-            provider.close()
-
-        # Print results in requested format
-        print_connection_results(results, out)
-        return 0
+            logger.close()
 
     except Exception as e:
         out.error(f"Error testing connection: {str(e)}")

{dblift-3.3.4 → dblift-3.4.0}/cli/extensions.py

@@ -8,7 +8,6 @@ from typing import Any, Callable, Dict
 COMMAND_ENTRY_POINT_GROUP = "dblift.commands"
 HANDLER_ENTRY_POINT_GROUP = "dblift.command_handlers"
 TERMINAL_ENTRY_POINT_GROUP = "dblift.terminal_commands"
-CommandExtension = Callable[[ArgumentParser], None]
 CommandHandler = Callable[[Any], tuple[bool, Any]]
 TerminalCommand = Callable[[Any], int]
 

{dblift-3.3.4 → dblift-3.4.0}/cli/handlers/_shared.py

@@ -73,9 +73,6 @@ class ConfigOnlyClient:
     config: Any
 
 
-ValidateSqlConfigClient = ConfigOnlyClient
-
-
 def _set_command_completed(log: Any, result: Any, command_type: str) -> None:
     """Helper to report command completion to the logger (eliminates SMELL-04 duplication)."""
     if result is None:

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

@@ -25,16 +25,6 @@ from cli._command_handlers import (  # noqa: F401
     PREMIUM_STUB_COMMANDS,
     CliCommandContext,
     _extract_version_filters,
-    _handle_baseline,
-    _handle_clean,
-    _handle_import_flyway,
-    _handle_info,
-    _handle_migrate,
-    _handle_repair,
-    _handle_undo,
-    _handle_validate,
-    _minimal_result,
-    _set_command_completed,
     _validate_migrate_options,
     execute_single_command,
 )
@@ -195,6 +185,41 @@ class _CliContext:
     license_info: Optional[Any] = None
 
 
+def _resolve_core_version() -> Optional[str]:
+    """Return the installed ``dblift`` core distribution version.
+
+    In a dev checkout, ``importlib.metadata.version("dblift")`` scans
+    ``sys.path`` for ANY distribution metadata matching the name "dblift" —
+    it does not verify that metadata belongs to the code actually executing,
+    so a stale or shadowing install elsewhere on ``sys.path`` can win over the
+    running source. The bundled ``__init__.py`` at the project root is the
+    freshest, least ambiguous ground truth for "what version is this code",
+    so it is tried first. Under a frozen build, though, the filesystem layout
+    is unreliable, so the walk is skipped entirely and ``importlib.metadata``
+    is used instead.
+    """
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _version
+
+    if not getattr(sys, "frozen", False):
+        try:
+            init_file = _project_root / "__init__.py"
+            if init_file.exists():
+                with open(init_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        if line.startswith("__version__"):
+                            parts = line.split("=", 1)
+                            if len(parts) == 2:
+                                return parts[1].strip().strip('"').strip("'")
+        except Exception:
+            pass
+
+    try:
+        return _version("dblift")
+    except PackageNotFoundError:
+        return None
+
+
 def _format_version() -> str:
     """Render the ``--version`` output.
 
@@ -216,7 +241,7 @@ def _format_version() -> str:
         except PackageNotFoundError:
             return None
 
-    core = _get("dblift")
+    core = _resolve_core_version()
     pro = _get("dblift-pro")
     enterprise = _get("dblift-enterprise")
 
@@ -346,6 +371,27 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
 
         sys.exit(run_config_command(args))
 
+    # A handler marked ``_dblift_zero_config_command`` needs no project
+    # config at all (e.g. a paid `license` command checking
+    # ~/.dblift/license.key — nothing to do with a database). Unlike the
+    # `config`/`db` short-circuits above, OSS can't spell the command name
+    # here: only core/premium_manifest.py may name a paid-edition command.
+    # So this is driven purely by a handler attribute, read generically off
+    # whatever's registered for the command — same pattern as
+    # ``_dblift_config_only_client``/``_dblift_skip_secret_resolution``.
+    # Single-command only: firing on ``commands[0]`` unconditionally would
+    # silently drop the rest of a chained invocation (e.g. `dblift license
+    # migrate`) instead of running it. A chained zero-config command falls
+    # through to the normal config-requiring pipeline instead — consistent
+    # with how ``_build_command_client`` already gates its own
+    # single-command-only optimization the same way.
+    if len(commands) == 1 and _command_handler_attr(
+        commands[0], "_dblift_zero_config_command", False
+    ):
+        handler = _COMMAND_HANDLERS[commands[0]]
+        success, _payload = handler(CliCommandContext(args=args))
+        sys.exit(0 if success else 1)
+
     log = LogFactory.get_log("Dblift")
     parser = create_parser()
     # Validate log format before any config load so bogus --log-format fails with argparse
@@ -495,8 +541,7 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
     if placeholders:
         ctx.log.debug(f"Using placeholders: {placeholders}")
 
-    ctx.config.journal_enabled = True
-    if getattr(ctx.args, "strict", False):
+    if getattr(ctx.config, "strict_mode", False) or getattr(ctx.args, "strict_mode", False):
         ctx.config.strict_mode = True
         ctx.log.info(
             "Strict mode is enabled. All migrations will be validated against strict rules."
@@ -577,6 +622,11 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
         _close_logs(ctx.log)
         return 1 if any_command_failed else 0
 
+    except SystemExit:
+        # CapabilityDeniedError (and other intentional exits) re-raise
+        # SystemExit with a dedicated code; flush logs then propagate.
+        _close_logs(ctx.log)
+        raise
     except Exception as e:
         ctx.log.error(f"Unexpected error: {str(e)}")
         ctx.log.error_with_exception("Command execution failed", e)

dblift-3.4.0/cli/premium_manifest.py

@@ -0,0 +1,28 @@
+"""Backward-compatible re-export of the premium-command catalog.
+
+The catalog itself lives in ``core/premium_manifest.py`` now — both
+``cli/`` and ``api/`` need it, and the ``cli-is-topmost`` .importlinter
+contract forbids ``api`` from importing ``cli``, so it moved to a layer
+both can reach. This module keeps ``from cli.premium_manifest import ...``
+working unchanged for existing CLI code and tests.
+"""
+
+from __future__ import annotations
+
+from core.premium_manifest import (
+    PREMIUM_COMMANDS,
+    UPGRADE_URL,
+    PremiumCommand,
+    premium_commands_missing_from,
+    premium_stub_index,
+    render_upsell,
+)
+
+__all__ = [
+    "PREMIUM_COMMANDS",
+    "UPGRADE_URL",
+    "PremiumCommand",
+    "premium_commands_missing_from",
+    "premium_stub_index",
+    "render_upsell",
+]

{dblift-3.3.4 → dblift-3.4.0}/config/database_config.py

@@ -9,7 +9,6 @@ from config._url_builder_mixin import UrlBuilderMixin
 
 # Constants will be ported separately if needed
 DEFAULT_CONNECTION_TIMEOUT_SECONDS = 30
-ORACLE_DEFAULT_PORT = 1521
 
 
 def _detect_dialect_from_url(url: str) -> str:
@@ -361,7 +360,9 @@ def _resolve_config_or_stub(
         return config_class
     if data.get("_allow_incomplete"):
         return _build_incomplete_stub(data, db_type)
-    raise ValueError(f"Unsupported database type: {db_type}")
+    if db_type:
+        raise ValueError(f"Unsupported database type: {db_type}")
+    raise ValueError(f"Unsupported database type: {data.get('url', '')!r}")
 
 
 def _instantiate_config(
@@ -381,11 +382,6 @@ class BaseDatabaseConfig(UrlBuilderMixin, ABC):
     # Registry of database types to their config classes
     _registry: ClassVar[Dict[str, Type["BaseDatabaseConfig"]]] = {}
 
-    @staticmethod
-    def _safe_str(value: Optional[str], default: str = "") -> str:
-        """Safely handle optional string values."""
-        return value if value is not None else default
-
     # Common parameters across all database types
     type: str
     url: str = ""