dblift 2.2.0__tar.gz → 2.2.2__tar.gz

{dblift-2.2.0 → dblift-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.2.0
+Version: 2.2.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-2.2.2/api/__init__.py

@@ -0,0 +1,16 @@
+"""Public API for DBLift library integration.
+
+This module provides a clean Python API for using DBLift programmatically,
+enabling integration with IDEs, CI/CD pipelines, and other development tools.
+"""
+
+from api.client import DBLiftClient
+from api.events import EventEmitter, EventType
+from api.migrations import MigrationContext
+
+__all__ = [  # noqa: F822
+    "DBLiftClient",
+    "EventEmitter",
+    "EventType",
+    "MigrationContext",
+]

{dblift-2.2.0 → dblift-2.2.2}/api/_client_operations.py

@@ -1,4 +1,8 @@
-"""Private operation helpers for OSS :mod:`api.client`."""
+"""Private operation helpers for :mod:`api.client`.
+
+Keep large operation bodies out of ``DBLiftClient`` so the public client class
+stays readable while preserving the same public methods and behavior.
+"""
 
 from __future__ import annotations
 
@@ -19,7 +23,7 @@ def _heuristic_statement_count_from_sql(sql_text: str) -> int:
 
 
 def _apply_sql_script_warning_scan(
-    result: GenerateUndoScriptResult,
+    result: Union[Any, GenerateUndoScriptResult],
     sql_text: str,
 ) -> None:
     """Set manual-review flag and collect per-line warnings from generated SQL text."""

{dblift-2.2.0 → dblift-2.2.2}/api/client.py

@@ -1,7 +1,6 @@
 """Main client for programmatic access to DBLift."""
 
 from functools import wraps
-from importlib import import_module
 from pathlib import Path
 from types import TracebackType
 from typing import (
@@ -25,10 +24,7 @@ from api._client_factory import (
     normalize_migrations_dirs,
     resolve_config_or_raise,
 )
-from api._client_operations import (
-    generate_undo_script_operation,
-    generate_undo_scripts_operation,
-)
+from api._client_operations import generate_undo_script_operation, generate_undo_scripts_operation
 from api.events import EventEmitter, EventType, use_client_emitter
 from config import DbliftConfig
 from core.logger.results import (
@@ -44,6 +40,7 @@ from core.logger.results import (
 )
 from core.migration.executor.migration_executor import MigrationExecutor
 from core.seams.event_listeners import attach_registered_listeners
+from core.seams.feature_loading import load_feature_extensions
 from db.base_provider import BaseProvider
 from db.provider_interfaces import ConnectionProvider, TransactionalProvider
 
@@ -119,6 +116,13 @@ class DBLiftClient:
             log_file: Optional log file path; omit to keep ``config`` values
             **kwargs: Additional configuration options
         """
+        # Feature registrations from installed add-on packages must load for
+        # every client construction path, not just CLI startup — otherwise the
+        # runtime-check and tier-resolver seams would silently no-op for
+        # API-only usage. Idempotent (module-level once-flag), so double-loading
+        # with the CLI's own call is harmless.
+        load_feature_extensions()
+
         # Resolve config before logger so defaults come from merged config (e.g. from file).
         config = resolve_config_or_raise(provider, config)
 

{dblift-2.2.0 → dblift-2.2.2}/cli/_config_helpers.py

@@ -35,15 +35,37 @@ _SUBCOMMAND_BOOLEAN_FLAGS = frozenset(
         "--clean-disabled",
         "--clean-enabled",
         "--dry-run",
+        "--generate-sql",
+        "--ignore-unmanaged",
+        "--include-drops",
+        "--keep-container",
+        "--managed-only",
         "--mark-as-executed",
+        "--no-performance",
         "--show-sql",
+        "--rehearse-rollback",
+        "--skip-replay",
         "--skip-validation",
+        "--skip-validate-sql",
+        "--split-by-type",
         "--strict",
+        "--unmanaged-only",
         "--validate-only",
     }
 )
 
 
+def _command_handler_attr(command: Optional[str], attr_name: str, default: Any = None) -> Any:
+    if not command:
+        return default
+    from cli._command_handlers import _COMMAND_HANDLERS
+
+    handler = _COMMAND_HANDLERS.get(command)
+    if handler is None:
+        return default
+    return getattr(handler, attr_name, default)
+
+
 def _extract_commands_from_argv(
     argv_list: List[str],
     available_commands: List[str],
@@ -257,16 +279,21 @@ def _load_and_merge_config(args: argparse.Namespace, log: Any) -> Any:
         db_overrides["schema"] = args.database_schema
 
     if db_overrides:
-        # Resolve secret URIs in CLI overrides.
-        from config.secrets._resolver import resolve_secret_refs
+        command = getattr(args, "command", None)
+        commands_list = getattr(args, "commands_list", None) or ([command] if command else [])
+        is_offline = len(commands_list) == 1 and bool(
+            _command_handler_attr(command, "_dblift_skip_secret_resolution", False)
+        )
+        if not is_offline:
+            from config.secrets._resolver import resolve_secret_refs
 
-        try:
-            db_overrides = resolve_secret_refs({"database": db_overrides}, config.secrets).get(
-                "database", db_overrides
-            )
-        except SecretsResolutionError as e:
-            print(f"Error: {e}", file=sys.stderr)
-            sys.exit(1)
+            try:
+                db_overrides = resolve_secret_refs({"database": db_overrides}, config.secrets).get(
+                    "database", db_overrides
+                )
+            except SecretsResolutionError as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
         config.database = ConfigBuilder.merge_database_overrides(config.database, db_overrides)
 
     if log:
@@ -321,7 +348,7 @@ def _validate_db_config(
     if commands and commands[0] == "db":
         return
 
-    migration_commands = [
+    migration_commands = {
         "migrate",
         "undo",
         "clean",
@@ -330,7 +357,9 @@ def _validate_db_config(
         "repair",
         "import-flyway",
         "baseline",
-    ]
+    }
+    if _command_handler_attr(args.command, "_dblift_validate_db_config", False):
+        migration_commands.add(args.command)
     if args.command not in migration_commands:
         return
 

{dblift-2.2.0 → dblift-2.2.2}/cli/_output.py

@@ -13,7 +13,8 @@ dispatch in ``cli/main.py`` re-derive the same predicate:
     else:
         ctx.log.info(payload)          # routed through ConsoleLog
 
-That duplication has already caused banner-routing regressions. ADR-0005 added the
+That duplication has already caused two regressions (PR 158 banner fix
++ PR-01 machine-format scope). ADR-0005 added the
 `MACHINE_READABLE_FORMATS` set as a single source of truth; this
 module does the same for the *routing* decision itself.
 

{dblift-2.2.0 → dblift-2.2.2}/cli/_parser_setup.py

@@ -116,6 +116,8 @@ def _add_registry_flags(parser: argparse.ArgumentParser) -> None:
     """
     from config.property_registry import PROPERTY_REGISTRY
 
+    deferred_specs = {"max_snapshots", "snapshot_table"}
+
     # Collect option strings across the WHOLE tree (root + every subparser), not
     # just the root parser. Many registry properties (e.g. --tags,
     # --target-version, --snapshot-table) intentionally live only on specific
@@ -137,6 +139,8 @@ def _add_registry_flags(parser: argparse.ArgumentParser) -> None:
     for spec in PROPERTY_REGISTRY:
         if spec.cli_only or spec.cli_exempt or "." in spec.name:
             continue
+        if spec.name in deferred_specs:
+            continue
         if spec.cli_aliases:
             continue  # legacy flag (e.g. --table, --strict) already provides the surface
         if spec.cli in existing:
@@ -202,7 +206,7 @@ def _make_filter_parent() -> argparse.ArgumentParser:
 
 # NOTE: ``--target-version`` is intentionally NOT extracted into a parent
 # parser. Its help text is genuinely command-specific (migrate / undo /
-# diff each describe a different intent) and unifying it would degrade
+# validate each describe a different intent) and unifying it would degrade
 # `--help` output. Each subparser adds it explicitly in
 # ``_add_diff_and_target_options`` so the user-facing string stays
 # accurate. See Bugbot review on PR-09.
@@ -232,13 +236,12 @@ def _add_baseline_options(baseline_parser: argparse.ArgumentParser) -> None:
 
 
 def _add_diff_and_target_options(
-    diff_parser: argparse.ArgumentParser | None,
     migrate_parser: argparse.ArgumentParser,
     undo_parser: argparse.ArgumentParser,
     validate_parser: argparse.ArgumentParser,
     clean_parser: argparse.ArgumentParser,
 ) -> None:
-    """Configure diff/migrate/undo/validate/clean subcommand-specific options.
+    """Configure migrate/undo/validate/clean subcommand-specific options.
 
     ``--target-version`` is added per-command (rather than via a shared
     parent parser) because each command has a meaningfully different
@@ -290,6 +293,21 @@ def _add_diff_and_target_options(
     )
 
 
+def _register_builtin_command_parsers(
+    parser: argparse.ArgumentParser,
+) -> list[argparse.ArgumentParser]:
+    """Register first-party command parsers that remain in the OSS CLI."""
+    subparser_actions = [
+        action for action in parser._actions if isinstance(action, argparse._SubParsersAction)
+    ]
+    if not subparser_actions:
+        return []
+
+    registered: list[argparse.ArgumentParser] = []
+
+    return registered
+
+
 def create_parser(
     exit_on_error: bool = True, suppress_errors: bool = False
 ) -> argparse.ArgumentParser:
@@ -441,10 +459,10 @@ def create_parser(
         default="flyway_schema_history",
         help="Source Flyway schema history table name (default: flyway_schema_history)",
     )
-    builtin_extension_parsers: list[argparse.ArgumentParser] = []
+    builtin_extension_parsers = _register_builtin_command_parsers(parser)
     # Configure arguments via extracted functions
     _add_baseline_options(baseline_parser)
-    _add_diff_and_target_options(None, migrate_parser, undo_parser, validate_parser, clean_parser)
+    _add_diff_and_target_options(migrate_parser, undo_parser, validate_parser, clean_parser)
     # info --format option (JSON output for scripting)
     info_parser.add_argument(
         "--format",

{dblift-2.2.0 → dblift-2.2.2}/cli/handlers/_shared.py

@@ -12,11 +12,9 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from core.features import FeatureTier
-
-# Flyway-compatible migration filename patterns used to skip non-migration
-# SQL files when scanning a directory (e.g. leftover temp files, schema
-# dumps) so only intentional migration scripts are
+# Flyway-compatible migration filename patterns — used by SQL-file validation to
+# skip non-migration SQL files when scanning a directory (e.g. leftover
+# temp files, schema dumps) so only intentional migration scripts are
 # checked. Explicitly-listed files are always validated regardless of name.
 _MIGRATION_FILENAME_RE = re.compile(
     r"^[VRUBvrub][\d_.]*__.*\.sql$",
@@ -61,9 +59,21 @@ class CliCommandContext:
     # Migration configuration
     placeholders: Dict[str, Any] = field(default_factory=dict)
     dir_recursive_map: Dict[Path, bool] = field(default_factory=dict)
-    # License tier for feature-level gates. execute_single_command supplies
-    # the real CLI-resolved tier; the default keeps direct handler tests terse.
-    license_tier: FeatureTier = FeatureTier.ENTERPRISE
+    # License tier for feature-level gates. Opaque to OSS (see
+    # core.seams.tier_resolver) — execute_single_command supplies the real
+    # CLI-resolved tier; paid-tier handler tests must pass their own tier
+    # explicitly since OSS no longer has a permissive default to fall back on.
+    license_tier: Any = None
+
+
+@dataclass
+class ConfigOnlyClient:
+    """Config-only stand-in for commands that do not need a live provider."""
+
+    config: Any
+
+
+ValidateSqlConfigClient = ConfigOnlyClient
 
 
 def _set_command_completed(log: Any, result: Any, command_type: str) -> None:
@@ -92,7 +102,7 @@ def emit_rendered_output(
 ) -> None:
     """Dispatch a rendered command output to machine channel, logger, and/or file.
 
-    Used by command handlers that follow the same machine/human/file
+    Shared by extension report handlers that follow the same machine/human/file
     dispatch pattern once the command-specific rendering is done.
     """
     if command_output.is_machine_format:
@@ -111,7 +121,7 @@ def emit_rendered_output(
 
 
 def _extract_version_filters(args: Any) -> tuple[Any, Any, Any, Any, Any]:
-    """Extract version/tag filter arguments common to migrate, undo, validate, info, diff handlers.
+    """Extract version/tag filter arguments common to filtered migration handlers.
 
     Returns:
         Tuple (target_version, versions, exclude_versions, tags, exclude_tags),

{dblift-2.2.0 → dblift-2.2.2}/cli/main.py

@@ -50,13 +50,10 @@ from cli._config_helpers import (  # noqa: F401
     _validate_log_format_for_cli,
 )
 from cli._output import CommandOutput, from_args
-from cli._parser_setup import (  # noqa: F401
-    _add_baseline_options,
-    _add_diff_and_target_options,
-    create_parser,
-    parse_with_selective_errors,
-)
+from cli._parser_setup import create_parser, parse_with_selective_errors
 from cli.extensions import load_terminal_commands
+from core.seams.feature_loading import load_feature_extensions
+from core.seams.license_info import get_license_info
 
 # Module-level placeholder; main() uses a local 'log' variable (no global declaration)
 log = None
@@ -102,16 +99,13 @@ _GLOBAL_ONLY_ARGS: List[str] = [
     "--quiet",
     "-q",
     "--no-progress",
-    # Root-only value flags surfaced from the PropertySpec registry
-    # (installed_by is added directly; max_snapshots is generated by
-    # _add_registry_flags). They live only on the root parser, so — like the
+    # Root-only value flags. They live only on the root parser, so — like the
     # other root-only value flags above — they must be classified global or the
     # argv preprocessor relocates them past the subcommand token and the
     # subparser rejects them as "unrecognized arguments". Covered by
     # tests/unit/cli/test_global_only_args_completeness.py.
     "--installed-by",
     "--max-snapshots",
-    "--snapshot-table",
 ]
 
 # Tool-level flag aliases for subcommands that take their own version-like
@@ -145,7 +139,10 @@ class _CliContext:
     log: Any  # core.logger Log — bootstrap instance (re-assigned by phase 3).
     config: Optional[Any]  # config.DbliftConfig | None (None for `db` subcommands)
 
-    # Optional paid extension metadata.
+    # Optional paid extension metadata. Populated from the
+    # ``core.seams.license_info`` seam: ``None`` in a pure OSS install (no
+    # provider registered), a license-info dict when a higher tier registers one.
+    license_info: Optional[Any] = None
 
 
 def main() -> None:
@@ -164,6 +161,7 @@ def main() -> None:
     from core.logger.console import install_rich_traceback
 
     install_rich_traceback()
+    load_feature_extensions()
 
     ctx = _parse_argv_and_load_config(sys.argv[1:])
     command_output = _setup_logging_and_output(ctx)
@@ -251,7 +249,8 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
     # Validate log format before any config load so bogus --log-format fails with argparse
     # UX (and so db/* commands are covered — _validate_db_config skips early for "db").
     _validate_log_format_for_cli(args, parser)
-    # Attach the full command list so load_config can see chained invocations.
+    # Attach the full command list so config loading can distinguish
+    # single-command config-only flows from chained invocations.
     args.commands_list = commands
     config = None if commands[0] == "db" else _load_and_merge_config(args, log)
     _validate_db_config(args, config, parser, commands)
@@ -264,6 +263,7 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
         parser=parser,
         log=log,
         config=config,
+        license_info=get_license_info(args),
     )
 
 
@@ -277,6 +277,27 @@ def _build_terminal_args(
     return args
 
 
+def _command_handler_attr(command: Optional[str], attr_name: str, default: Any = None) -> Any:
+    if not command:
+        return default
+    handler = _COMMAND_HANDLERS.get(command)
+    if handler is None:
+        return default
+    return getattr(handler, attr_name, default)
+
+
+def _propagate_license_banner(log: Any, license_info: Optional[Any]) -> None:
+    """Set ``license_info`` on every sub-logger's formatter so the banner
+    renders. No-op when ``license_info`` is falsy (pure OSS: no provider
+    registered on the ``core.seams.license_info`` seam)."""
+    if not license_info:
+        return
+    loggers = getattr(log, "logs", [log])
+    for sub_log in loggers:
+        if hasattr(sub_log, "formatter"):
+            sub_log.formatter.license_info = license_info
+
+
 def _setup_logging_and_output(ctx: _CliContext) -> CommandOutput:
     """Phase 3: configure logging, build :class:`CommandOutput`.
 
@@ -305,6 +326,12 @@ def _setup_logging_and_output(ctx: _CliContext) -> CommandOutput:
 
     assert ctx.config is not None
     ctx.log = _configure_logging(ctx.args, ctx.config, ctx.parser)
+    # Propagate the license banner (if a higher tier registered a provider on
+    # the seam) onto the reconfigured loggers' formatters. No-op in a pure OSS
+    # install where ``ctx.license_info`` is ``None``.
+    _propagate_license_banner(ctx.log, ctx.license_info)
+
+    _apply_configured_output_format(ctx)
 
     # Banner routing is centralised in :class:`cli._output.CommandOutput`
     # (ADR-0008 supersedes ADR-0005's suppression approach). Machine
@@ -312,6 +339,18 @@ def _setup_logging_and_output(ctx: _CliContext) -> CommandOutput:
     return from_args(ctx.args)
 
 
+def _apply_configured_output_format(ctx: _CliContext) -> None:
+    """Use handler-provided config defaults before top-level banner routing."""
+    if len(ctx.commands) != 1 or getattr(ctx.args, "format", None):
+        return
+    resolver = _command_handler_attr(ctx.commands[0], "_dblift_configured_output_format")
+    if not callable(resolver):
+        return
+    output_format = resolver(ctx.args, ctx.config)
+    if output_format:
+        ctx.args.format = output_format
+
+
 def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
     """Phase 4: build full workflow context and run the command loop.
 
@@ -350,6 +389,7 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
         )
         schema_name = getattr(ctx.config.database, "schema", None)
         formatter = TextFormatter()
+        formatter.license_info = ctx.license_info
         main_header = formatter.format_header(schema_name, database_name)
 
         from core.migration.commands import base_command
@@ -362,6 +402,13 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
         # in base_command does not re-emit it (it also has no format awareness).
         if main_header:
             base_command._console_main_header_printed = True  # type: ignore[attr-defined]
+            for command in ctx.commands:
+                handler = _COMMAND_HANDLERS.get(command)
+                if handler is None:
+                    continue
+                command_module = sys.modules.get(handler.__module__)
+                if command_module is not None:
+                    command_module._console_main_header_printed = True  # type: ignore[attr-defined]
 
         for cmd_index, command in enumerate(ctx.commands):
             if len(ctx.commands) > 1 and cmd_index > 0:

{dblift-2.2.0 → dblift-2.2.2}/config/database_config.py

@@ -199,9 +199,9 @@ def _apply_url_overrides(cls: Type["BaseDatabaseConfig"], data: Dict[str, Any])
         if url_lower.startswith("jdbc:"):
             raise ValueError("Legacy database URLs are no longer supported; use a SQLAlchemy URL")
         # _allow_incomplete is set when the URL could not be parsed (e.g. an
-        # unresolved secret URI in offline mode). Skip hydration/inference so
-        # an unresolved secret URI doesn't mutate fields before a connection
-        # is opened.
+        # unresolved secret URI in offline mode). Skip hydration/inference so that
+        # `dblift plan` with `database.url: vault://...` doesn't mutate fields from
+        # the secret URI before a connection is opened.
         if data.get("_allow_incomplete"):
             return
         if ProviderRegistry.is_native_dialect(db_type):

{dblift-2.2.0 → dblift-2.2.2}/config/dblift_config.py

@@ -25,6 +25,56 @@ _CONFIG_LOAD_EXC: Tuple[Type[Exception], ...] = (
     AttributeError,
     IndexError,
 )
+_PAID_RAW_CONFIG_KEYS: Tuple[str, ...] = ("data_sets", "datasets", "validation")
+
+
+# ``validate-sql`` only needs a dialect-typed DbliftConfig; connection is never opened.
+# Placeholder database URLs satisfy :meth:`DbliftConfig.validate_complete_data` and are never
+# used to connect in the validate-sql code path.
+def _validate_sql_lint_filler(dialect: str) -> Dict[str, Any]:
+    """Minimal ``database:`` block for validate-sql (lint-only) when no real DB is configured.
+
+    Story 26-11: dialect normalisation + placeholder URL come from the
+    plugin registry / quirks. The earlier hardcoded
+    ``_VALIDATE_SQL_DIALECT_TO_DB``, ``_VALIDATE_SQL_PLACEHOLDER_URL``,
+    and ``_VALIDATE_SQL_DB_TO_DIALECT`` dicts are gone; adding a new
+    dialect with offline-lint support = override
+    ``lint_placeholder_url`` in its plugin quirks.py.
+    """
+    from db.provider_registry import ProviderRegistry
+
+    db_type = ProviderRegistry.canonical_dialect_name((dialect or "").strip().lower())
+    if not db_type:
+        return {}
+    quirks = ProviderRegistry.get_quirks(db_type)
+    placeholder = quirks.lint_placeholder_url
+    if not placeholder:
+        return {}
+    return {
+        "database": {
+            "type": db_type,
+            "url": placeholder,
+            "username": "dblift_validate_sql",
+            "password": "dblift_validate_sql",
+        }
+    }
+
+
+def _validate_sql_effective_dialect(args: Any, config_data: Dict[str, Any]) -> Optional[str]:
+    """Resolve validate-sql dialect from CLI or config without defaulting."""
+    cli_dialect = getattr(args, "dialect", None)
+    if isinstance(cli_dialect, str) and cli_dialect.strip():
+        return cli_dialect.strip().lower()
+
+    database_config = config_data.get("database")
+    if isinstance(database_config, dict):
+        from db.provider_registry import ProviderRegistry
+
+        db_type = str(database_config.get("type") or "").strip().lower()
+        if db_type:
+            return ProviderRegistry.canonical_dialect_name(db_type) or db_type
+
+    return None
 
 
 def _placeholder_tokens(raw_placeholders: Any) -> List[str]:
@@ -79,6 +129,15 @@ def _resolve_env_placeholders(data: Any) -> Any:
     return data
 
 
+def _extract_paid_raw_config(data: Dict[str, Any]) -> Dict[str, Any]:
+    paid_raw: Dict[str, Any] = {}
+    for key in _PAID_RAW_CONFIG_KEYS:
+        value = data.get(key)
+        if value is not None:
+            paid_raw[key] = value
+    return paid_raw
+
+
 def load_config(config_file_path: Optional[str], args: Optional[Any] = None) -> "DbliftConfig":
     """
     Load configuration from a file and override with command line arguments
@@ -119,13 +178,33 @@ def load_config(config_file_path: Optional[str], args: Optional[Any] = None) ->
         if args_dict:
             config_data = DbliftConfig.merge_config_data(config_data, args_dict)
 
+    # ``validate-sql`` does not need a real database, but static linting does
+    # need an explicit SQL dialect or a database type from config.
+    if args and getattr(args, "command", None) == "validate-sql":
+        dialect = _validate_sql_effective_dialect(args, config_data)
+        if not dialect:
+            raise ConfigurationError(
+                "validate-sql requires --dialect for offline validation when no database type is configured."
+            )
+        filler = _validate_sql_lint_filler(dialect)
+        if filler:
+            config_data = DbliftConfig.merge_config_data(filler, config_data)
+
     if not config_data:
         raise ConfigurationError(
             "No configuration source provided. Pass --config, --db-url, or set DBLIFT_DB_URL."
         )
 
-    is_offline_cmd = False
+    command = getattr(args, "command", None) if args else None
+    commands_list = getattr(args, "commands_list", None) if args else None
+    if commands_list is None and command:
+        commands_list = [command]
+    is_offline_cmd = bool(
+        command in ("validate-sql", "plan") and commands_list and len(commands_list) == 1
+    )
     config = DbliftConfig.from_dict(config_data, resolve_secrets=not is_offline_cmd)
+    if config_file_path:
+        setattr(config, "_config_file_path", config_file_path)
     if args:
         installed_by = getattr(args, "installed_by", None)
         if installed_by:
@@ -431,13 +510,14 @@ class DbliftConfig:
         Args:
             data: Configuration dictionary
             resolve_secrets: When False, skip secret-URI resolution (used for
-                offline commands that never open a DB connection and must not
-                require secret-manager credentials to be available).
+                offline commands such as static SQL lint that never open a DB connection
+                and must not require secret-manager credentials to be available).
 
         Returns:
             A DbliftConfig instance
         """
         data = _resolve_env_placeholders(data or {})
+        paid_raw_config = _extract_paid_raw_config(data)
 
         if resolve_secrets:
             # Two-phase secret resolution:
@@ -483,7 +563,7 @@ class DbliftConfig:
                 # Non-secret unparseable URLs are left as-is so _apply_url_overrides
                 # raises a focused URL error immediately rather than producing a
                 # silently broken config.
-        # When secrets are not resolved (offline commands),
+        # When secrets are not resolved (offline commands like plan/validate-sql),
         # a secret URI in database.url must not be validated as a database URL — the
         # type may already be known from database.type but the URL is still raw.
         # This covers the case where database.type is set explicitly, which skips
@@ -614,6 +694,8 @@ class DbliftConfig:
             secrets=secrets_config,
         )
         config.log_dir = root_log_dir
+        if paid_raw_config:
+            setattr(config, "_paid_config_data", paid_raw_config)
         return config
 
     @staticmethod
@@ -922,7 +1004,9 @@ class DbliftConfig:
                 config_data = _resolve_env_placeholders(config_data)
                 if not config_data:
                     raise yaml.YAMLError("Empty or invalid YAML file")
-                return cls.from_dict(config_data)
+                config = cls.from_dict(config_data)
+                setattr(config, "_config_file_path", str(config_file))
+                return config
         except FileNotFoundError:
             raise FileNotFoundError(f"Config file not found: {config_file}")
         except yaml.YAMLError as e:

{dblift-2.2.0 → dblift-2.2.2}/config/secrets/_registry.py

@@ -1,12 +1,13 @@
 """Provider class registry — maps URI schemes to provider classes."""
 
-from importlib import import_module
 from importlib.metadata import entry_points
 from typing import Dict, Optional, Set, Type
 
 # Fixed set of known schemes — used for fast URI detection without requiring
 # providers to be registered first (avoids import-order sensitivity).
-KNOWN_SCHEMES: frozenset = frozenset()
+KNOWN_SCHEMES: frozenset = frozenset(
+    ["vault", "aws-secrets", "aws-ssm", "azure-keyvault", "gcp-secrets"]
+)
 
 # Populated by providers/__init__.py at import time.
 _providers: Dict[str, Type] = {}