dblift 2.0.4__tar.gz → 2.1.0__tar.gz

{dblift-2.0.4 → dblift-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.0.4
+Version: 2.1.0
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -78,22 +78,30 @@ Provides-Extra: all
 Requires-Dist: dblift[db2,mariadb,mysql,oracle,postgresql,sqlserver]; extra == "all"
 Dynamic: license-file
 
-# DBLift User Guide
+# DBLift — Database release safety for Python teams
 
 <p align="center">
-  <img src="logo/dblift_logo.png" width="600" alt="Dblift Logo">
+  <img src="logo/dblift_logo.png" width="280" alt="DBLift Logo">
 </p>
 
-**Manage your database changes with confidence**
-
-DBLift helps you track and apply database changes systematically. Think of it as version control for your database schema - every change is tracked, can be rolled back, and works consistently across different environments.
-
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-
 [![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
+Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.
+
+```bash
+pip install "dblift[postgresql]"
+
+dblift validate                        # check migration state
+dblift migrate --dry-run --show-sql    # preview exact SQL before it runs
+dblift migrate                         # apply when ready
+```
+
+> **OSS tier:** The commands above are free and open source (Apache 2.0). Static SQL analysis (`dblift validate-sql`) and schema drift detection (`dblift diff`) are [Pro features](https://dblift.com/pricing).
+
 ---
 
 ## Table of Contents
@@ -998,6 +1006,19 @@ dblift is a pip package with no system dependencies — CI is `pip install` plus
 command. See [CI/CD recipes](docs/user-guide/ci-cd.md) for copy-paste GitHub
 Actions, GitLab CI, and pre-commit configurations (OSS `validate` / `info`).
 
+## What Pro adds
+
+The OSS tier covers the full migration lifecycle: apply, preview, validate state,
+roll back, and import from Flyway. When review risk grows, the Pro tier adds:
+
+| Feature | Command | What it does |
+|---|---|---|
+| Static SQL analysis | `dblift validate-sql` | Lints migration files with rule-based checks — catches issues before they reach the database. Built-in rule profiles (core, enterprise, strict). CI-friendly output formats (GitHub Actions, SARIF, GitLab). |
+| Schema drift detection | `dblift diff` | Compares live database state with what your migrations define. Surfaces objects that have drifted. |
+| Schema export | `dblift export-schema` | Exports the current schema to SQL migration files. Useful for brownfield onboarding. |
+
+[See pricing and Pro features →](https://dblift.com/pricing)
+
 ## API Reference
 
 The Python SDK (`DBLiftClient`, `AsyncDBLiftClient`, `MigrationContext`), CLI,

{dblift-2.0.4 → dblift-2.1.0}/README.md

@@ -1,19 +1,27 @@
-# DBLift User Guide
+# DBLift — Database release safety for Python teams
 
 <p align="center">
-  <img src="logo/dblift_logo.png" width="600" alt="Dblift Logo">
+  <img src="logo/dblift_logo.png" width="280" alt="DBLift Logo">
 </p>
 
-**Manage your database changes with confidence**
-
-DBLift helps you track and apply database changes systematically. Think of it as version control for your database schema - every change is tracked, can be rolled back, and works consistently across different environments.
-
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-
 [![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
+Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.
+
+```bash
+pip install "dblift[postgresql]"
+
+dblift validate                        # check migration state
+dblift migrate --dry-run --show-sql    # preview exact SQL before it runs
+dblift migrate                         # apply when ready
+```
+
+> **OSS tier:** The commands above are free and open source (Apache 2.0). Static SQL analysis (`dblift validate-sql`) and schema drift detection (`dblift diff`) are [Pro features](https://dblift.com/pricing).
+
 ---
 
 ## Table of Contents
@@ -918,6 +926,19 @@ dblift is a pip package with no system dependencies — CI is `pip install` plus
 command. See [CI/CD recipes](docs/user-guide/ci-cd.md) for copy-paste GitHub
 Actions, GitLab CI, and pre-commit configurations (OSS `validate` / `info`).
 
+## What Pro adds
+
+The OSS tier covers the full migration lifecycle: apply, preview, validate state,
+roll back, and import from Flyway. When review risk grows, the Pro tier adds:
+
+| Feature | Command | What it does |
+|---|---|---|
+| Static SQL analysis | `dblift validate-sql` | Lints migration files with rule-based checks — catches issues before they reach the database. Built-in rule profiles (core, enterprise, strict). CI-friendly output formats (GitHub Actions, SARIF, GitLab). |
+| Schema drift detection | `dblift diff` | Compares live database state with what your migrations define. Surfaces objects that have drifted. |
+| Schema export | `dblift export-schema` | Exports the current schema to SQL migration files. Useful for brownfield onboarding. |
+
+[See pricing and Pro features →](https://dblift.com/pricing)
+
 ## API Reference
 
 The Python SDK (`DBLiftClient`, `AsyncDBLiftClient`, `MigrationContext`), CLI,

{dblift-2.0.4 → dblift-2.1.0}/api/_client_factory.py

@@ -349,7 +349,6 @@ def client_from_sqlalchemy(
         logger = build_default_logger(derived, log_level, log_format, log_file)
 
     provider = ProviderRegistry.create_provider(derived, logger)
-    dialect_name = str(getattr(engine.dialect, "name", ""))
 
     # Inject external engine so provider re-uses caller's Engine/Connection
     # (ownership=False prevents dispose on client/provider close).
@@ -357,14 +356,15 @@ def client_from_sqlalchemy(
         provider._conn_mgr = NativeConnectionManager(
             derived, logger, engine=engine, owns_engine=False
         )  # noqa: E501
-    elif dialect_name == "sqlite":  # lint: allow-dialect-string: stdlib sqlite3 provider path
+    elif hasattr(provider, "attach_external_sqlalchemy"):
         # The native SQLite provider talks to ``sqlite3`` directly instead of
         # through a NativeConnectionManager, so the branch above never fires for
-        # it. Without this, the provider would open its *own* ``sqlite3``
-        # connection and migrate a different database than the caller's engine —
-        # fatal for ``sqlite:///:memory:`` where every connection is a separate
-        # in-memory DB. Reach through the SQLAlchemy engine/connection to its
-        # underlying DBAPI ``sqlite3.Connection`` and hand that to the provider.
+        # it. It is the only provider exposing ``attach_external_sqlalchemy`` —
+        # the capability of reaching through a caller's SQLAlchemy engine to its
+        # underlying DBAPI connection. Without this, the provider would open its
+        # *own* ``sqlite3`` connection and migrate a different database than the
+        # caller's engine — fatal for ``sqlite:///:memory:`` where every
+        # connection is a separate in-memory DB.
         _attach_external_sqlite_connection(provider, engine, connection)
 
     # When a specific Connection was passed, bind it directly so that

{dblift-2.0.4 → dblift-2.1.0}/api/_engine_config.py

@@ -47,7 +47,10 @@ def config_from_engine(
         scheme = engine.url.drivername.split("+", 1)[0]
         db_type = ProviderRegistry.canonical_dialect_name(scheme) or scheme
     except Exception:
-        db_type = "postgresql"  # lint: allow-dialect-string: safe fallback only; real type comes from URL scheme + ProviderRegistry.canonical_dialect_name above  # noqa: E501
+        # The provider was already matched above, so it carries its own
+        # canonical dialect name — derive the fallback from it instead of
+        # naming a dialect here.
+        db_type = getattr(provider_cls, "canonical_dialect_key", "")
 
     db_dict: dict[str, Any] = {"url": url, "type": db_type}
     if schema is not None:

{dblift-2.0.4 → dblift-2.1.0}/api/client.py

@@ -203,12 +203,14 @@ class DBLiftClient:
             raise ValueError(
                 "Database type is configured but empty. Please set config.database.type to a valid dialect."
             )
-        return (
-            # lint: allow-dialect-string: dialect dispatch
-            config_dialect
-            # lint: allow-dialect-string: dialect dispatch
-            or "postgresql"
-        ).lower()  # lint: allow-dialect-string: dialect dispatch
+        if config_dialect:
+            return str(config_dialect).lower()
+        # Neither provider nor config supplied a dialect: fall back to the
+        # registry-derived generic dialect rather than a hardcoded literal
+        # (ADR-26 E5).
+        from core.migration.migration import _default_splitter_dialect
+
+        return _default_splitter_dialect().lower()
 
     @_with_client_emitter
     def migrate(

{dblift-2.0.4 → dblift-2.1.0}/cli/_config_helpers.py

@@ -75,7 +75,7 @@ def _extract_commands_from_argv(
             i += 1
             # Commands with subcommands: stop extracting further commands,
             # but continue loop so global args are still extracted
-            if arg in ("db", "license"):
+            if arg in ("db", "license", "data"):
                 stop_command_extraction = True
             continue
 

{dblift-2.0.4 → dblift-2.1.0}/cli/_parser_setup.py

@@ -13,6 +13,24 @@ from typing import Any, Dict, List, Optional, Tuple
 from cli.db_utils import setup_db_utils_parser
 
 
+def _native_dialect_choices() -> List[str]:
+    """Sorted native dialect names from the plugin registry (ADR-26 E5).
+
+    Replaces the hardcoded ``--dialect`` choices list so the CLI surface
+    tracks the registered plugins automatically — dropping a plugin folder
+    adds its dialect here with no string literal in framework code.
+    """
+    # Route through ``api.*`` (not ``db.provider_registry`` directly): cli/ is
+    # banned from importing the registry by .flake8 banned-modules (I251).
+    from api._cli_support import ProviderRegistry
+
+    return sorted(
+        p.name
+        for p in ProviderRegistry.list_plugins()
+        if ProviderRegistry.is_native_dialect(p.name)
+    )
+
+
 def parse_with_selective_errors(
     parser: argparse.ArgumentParser,
 ) -> Tuple[Optional[argparse.Namespace], List[str], bool]:

{dblift-2.0.4 → dblift-2.1.0}/cli/handlers/_shared.py

@@ -12,6 +12,8 @@ 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
@@ -59,6 +61,9 @@ 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
 
 
 def _set_command_completed(log: Any, result: Any, command_type: str) -> None:

{dblift-2.0.4 → dblift-2.1.0}/cli/main.py

@@ -382,6 +382,7 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
                 recursive=recursive,
                 placeholders=placeholders,
                 dir_recursive_map=dir_recursive_map,
+                license_tier=_resolve_license_tier(ctx.args),
             )
             if not success:
                 any_command_failed = True

dblift-2.1.0/config/_subclasses/__init__.py

@@ -0,0 +1,15 @@
+"""Non-dialect ``BaseDatabaseConfig`` subclass modules.
+
+The per-dialect configuration classes that used to live here have moved into
+their plugin packages (``db/plugins/<dialect>/config.py``, ADR-26 D /
+story 26-11): each plugin declares ``config_class=XxxConfig`` on its
+``PluginInfo`` and registers via plugin discovery, so adding a dialect no
+longer requires editing ``config/``.
+
+What remains is :mod:`config._subclasses.dummy_config` — a generic/test config
+that is **not** a plugin and therefore has no plugin to register through. It
+imports :class:`config.database_config.BaseDatabaseConfig` and uses
+``@register_database_type`` so its class is wired into the
+``BaseDatabaseConfig._registry`` at import time. The :mod:`config.database_config`
+facade eager-imports it to keep that registration eager.
+"""

{dblift-2.0.4 → dblift-2.1.0}/config/config_builder.py

@@ -10,11 +10,40 @@ from dataclasses import replace
 from pathlib import Path
 from typing import Any, Dict, Optional, Union
 
-from config.database_config import BaseDatabaseConfig, _detect_dialect_from_url
+from config.database_config import (
+    BaseDatabaseConfig,
+    _detect_dialect_from_url,
+    _native_canonical_from_scheme,
+)
 from config.dblift_config import DbliftConfig
 from config.errors import ConfigurationError
 
 
+def _file_url_dialect_from_scheme(scheme: str) -> Optional[str]:
+    """Resolve a URL scheme to its canonical dialect *iff* that dialect uses
+    file-URL semantics (ADR-26 E5).
+
+    A "file-URL" dialect is one whose quirks advertise
+    ``url_optional_when_file_path_given`` — the file path *is* the database, so
+    a stale ``database`` attribute on a copied config (e.g. SQL Server's
+    ``master``) must not win over the URL. SQLite is the only such native
+    dialect today; any future embedded/file-based plugin is handled the same
+    way without naming a dialect here.
+
+    Returns the canonical dialect name, or ``None`` when the scheme is unknown
+    or its dialect is not file-URL based.
+    """
+    canonical = _native_canonical_from_scheme(scheme)
+    if not canonical:
+        return None
+    from db.provider_registry import ProviderRegistry
+
+    quirks = ProviderRegistry.get_quirks(canonical)
+    if getattr(quirks, "url_optional_when_file_path_given", False):
+        return canonical
+    return None
+
+
 class ConfigBuilder:
     """Helper class for building and merging configurations."""
 
@@ -147,9 +176,10 @@ class ConfigBuilder:
             if hasattr(result, key):
                 setattr(result, key, value)
         if overrides.get("url"):
-            _url_lower = overrides["url"].lower()
-            if _url_lower.startswith(("sqlite:", "sqlite3:")):
-                result.type = "sqlite"  # lint: allow-dialect-string: dialect dispatch
+            _scheme = overrides["url"].strip().lower().split(":", 1)[0].split("+", 1)[0]
+            _file_dialect = _file_url_dialect_from_scheme(_scheme)
+            if _file_dialect:
+                result.type = _file_dialect
         return result
 
     @staticmethod
@@ -166,13 +196,19 @@ class ConfigBuilder:
         """
         if not overrides.get("url"):
             return None
-        _url_lower = overrides["url"].lower()
-        if not _url_lower.startswith(("sqlite:", "sqlite3:")):
+        _scheme = overrides["url"].strip().lower().split(":", 1)[0].split("+", 1)[0]
+        _file_dialect = _file_url_dialect_from_scheme(_scheme)
+        if not _file_dialect:
             return None
+        from db.provider_registry import ProviderRegistry
+
+        _default_schema = getattr(
+            ProviderRegistry.get_quirks(_file_dialect), "default_schema_name", None
+        )
         sqlite_data: Dict[str, Any] = {
-            "type": "sqlite",  # lint: allow-dialect-string: dialect dispatch
+            "type": _file_dialect,
             "url": overrides["url"],
-            "schema": overrides.get("schema", base_config.schema) or "main",
+            "schema": overrides.get("schema", base_config.schema) or _default_schema,
         }
         try:
             return BaseDatabaseConfig.create(sqlite_data)

{dblift-2.0.4 → dblift-2.1.0}/config/database_config.py

@@ -72,9 +72,6 @@ def _infer_type_from_url_scheme(data: Dict[str, Any]) -> None:
         _normalize_sqlite_url_alias(data)
         url = str(data.get("url") or "")
         url_lower = url.lower()
-        if url_lower.startswith(("sqlite:", "sqlite3:")):
-            data["type"] = "sqlite"  # lint: allow-dialect-string: URL-scheme inference
-            return
         scheme = url_lower.split(":", 1)[0].split("+", 1)[0]
         if scheme:
             canonical = _native_canonical_from_scheme(scheme)
@@ -102,24 +99,20 @@ def _normalize_sqlite_url_alias(data: Dict[str, Any]) -> None:
 
 
 def _infer_type_from_uri(data: Dict[str, Any], url: str) -> None:
-    """Handle bare ``sqlite:`` / ``sqlite3:`` URIs (PEP-249 / RFC 8085 style).
+    """Infer ``type`` for native URIs (e.g. ``sqlite:`` / ``sqlite3:``) via the registry.
 
-    Unknown schemes are left for normal validation so secret/offline URLs can
-    still flow through the incomplete-config path when requested.
+    The scheme is resolved through ``_native_canonical_from_scheme`` after the
+    ``sqlite3:`` alias is normalised. Unknown schemes are left for normal
+    validation so secret/offline URLs can still flow through the
+    incomplete-config path when requested.
     """
     _normalize_sqlite_url_alias(data)
     url = str(data.get("url") or url)
     url_l = (url or "").strip().lower()
-    if url_l.startswith("sqlite3:"):
-        data["type"] = "sqlite"  # lint: allow-dialect-string: URL-scheme inference
-    elif url_l.startswith("sqlite:"):
-        data["type"] = "sqlite"  # lint: allow-dialect-string: URL-scheme inference
-    else:
-        scheme = url_l.split(":", 1)[0].split("+", 1)[0]
-        canonical = _native_canonical_from_scheme(scheme)
-        if canonical:
-            data["type"] = canonical
-            return
+    scheme = url_l.split(":", 1)[0].split("+", 1)[0]
+    canonical = _native_canonical_from_scheme(scheme)
+    if canonical:
+        data["type"] = canonical
 
 
 def _hydrate_from_native_url(data: Dict[str, Any], url: str) -> None:
@@ -442,10 +435,12 @@ class BaseDatabaseConfig(UrlBuilderMixin, ABC):
 
     @classmethod
     def create(cls, data: Dict[str, Any]) -> "BaseDatabaseConfig":
-        # NOTE: per-dialect subclasses register themselves at the bottom of this
-        # module via eager imports of ``config._subclasses.*_config``; the
-        # ``BaseDatabaseConfig._registry`` lookup below depends on those
-        # registrations being in place by the time ``create()`` runs.
+        # NOTE: the config subclass for a dialect is resolved in
+        # ``_resolve_config_class`` — first via the eager ``_registry`` (only the
+        # non-dialect ``dummy`` config eager-imports here now), then via plugin
+        # discovery (``PluginInfo.config_class``). Per-dialect configs live in
+        # ``db/plugins/<X>/config.py`` (ADR-26 D); see the block at the bottom
+        # of this module.
         # Phase 1: infer a missing ``type`` from well-known URL schemes.
         _infer_type_from_url_scheme(data)
 
@@ -589,27 +584,18 @@ class DatabaseConfig:
 
 
 # ---------------------------------------------------------------------------
-# Re-export per-dialect subclasses so the legacy
-# ``from config.database_config import XxxConfig`` import path keeps working
-# (used by ~25 test modules and a couple of production sites).
-#
-# These imports are intentionally at the bottom of the module: each subclass
-# module imports ``BaseDatabaseConfig`` (and ``register_database_type``) from
-# this file, so the symbols above must be fully defined before we load them.
-# Importing the modules registers their classes via ``@register_database_type``.
+# Per-dialect config subclasses now live in their plugin packages
+# (``db/plugins/<dialect>/config.py``) and register via plugin discovery
+# (story 26-11 / ADR-26 D). Each plugin declares ``config_class=XxxConfig`` on
+# its ``PluginInfo`` and ``_resolve_config_class`` (above) picks it up through
+# the plugin registry — adding a dialect no longer requires editing ``config/``.
 #
-# Roadmap action #11: third-party plugins do **not** need to add to this list
-# — they declare ``config_class=MyConfig`` on their ``PluginInfo`` and
-# ``_resolve_config_class`` (above) picks it up via the plugin registry. The
-# eager imports below stay only because removing them would break the legacy
-# import path; they aren't the modern entry point for new dialects.
+# Only the non-dialect ``dummy`` config stays eager-imported here: it is a
+# generic/test config (not a plugin), so it has no plugin to register through.
+# The import is at the bottom because ``dummy_config`` imports
+# ``BaseDatabaseConfig`` (and ``register_database_type``) from this file, so the
+# symbols above must be fully defined first; importing it registers its class
+# via ``@register_database_type``.
 # ---------------------------------------------------------------------------
 
-from config._subclasses.cosmosdb_config import CosmosDbConfig  # noqa: E402, F401
-from config._subclasses.db2_config import Db2Config  # noqa: E402, F401
 from config._subclasses.dummy_config import DummyDatabaseConfig  # noqa: E402, F401
-from config._subclasses.mysql_config import MySqlConfig  # noqa: E402, F401
-from config._subclasses.oracle_config import OracleConfig  # noqa: E402, F401
-from config._subclasses.postgresql_config import PostgreSqlConfig  # noqa: E402, F401
-from config._subclasses.sqlite_config import SQLiteConfig  # noqa: E402, F401
-from config._subclasses.sqlserver_config import SqlServerConfig  # noqa: E402, F401

{dblift-2.0.4 → dblift-2.1.0}/config/dblift_config.py

@@ -471,14 +471,11 @@ class DbliftConfig:
         db_type = str(database_data.get("type") or "").strip().lower()
         url = str(database_data.get("url") or "").strip()
         if url and not db_type:
-            url_lower = url.lower()
-            if url_lower.startswith(("sqlite:", "sqlite3:")):
-                db_type = "sqlite"  # lint: allow-dialect-string: URL-scheme inference (sqlite:// URL maps to sqlite type)
-            else:
-                from db.provider_registry import ProviderRegistry
+            from db.provider_registry import ProviderRegistry
 
-                scheme = url_lower.split(":", 1)[0].split("+", 1)[0]
-                db_type = ProviderRegistry.canonical_dialect_name(scheme) or ""
+            url_lower = url.lower()
+            scheme = url_lower.split(":", 1)[0].split("+", 1)[0]
+            db_type = ProviderRegistry.canonical_dialect_name(scheme) or ""
             if not db_type:
                 from config.secrets._registry import is_secret_uri as _is_secret_uri_inline
 
@@ -642,11 +639,8 @@ class DbliftConfig:
         url = str(database.get("url") or "").strip()
         if not db_type and url:
             url_lower = url.lower()
-            if url_lower.startswith(("sqlite:", "sqlite3:")):
-                db_type = "sqlite"  # lint: allow-dialect-string: URL-scheme inference (sqlite:// URL maps to sqlite type)
-            else:
-                scheme = url_lower.split(":", 1)[0].split("+", 1)[0]
-                db_type = ProviderRegistry.canonical_dialect_name(scheme) or ""
+            scheme = url_lower.split(":", 1)[0].split("+", 1)[0]
+            db_type = ProviderRegistry.canonical_dialect_name(scheme) or ""
 
         if not db_type:
             if url:
@@ -654,11 +648,12 @@ class DbliftConfig:
             raise ConfigurationError("Database type is required in configuration")
 
         _quirks = ProviderRegistry.get_quirks(db_type)
-        # CosmosDB-specific auth validation: account_endpoint + account_key (or
-        # use_managed_identity). is_nosql is too generic — match the canonical
-        # plugin name so future NoSQL dialects don't inherit Azure-specific rules.
-        # lint: allow-dialect-string: CosmosDB Azure auth validation
-        if ProviderRegistry.canonical_dialect_name(db_type) == "cosmosdb":
+        # Cloud-account auth validation: account_endpoint + account_key (or
+        # use_managed_identity). Gated on the ``requires_cloud_account_auth``
+        # quirks capability (CosmosDB sets it True) rather than a hardcoded
+        # dialect name. ``is_nosql`` is deliberately not reused — it is too
+        # generic, so future NoSQL dialects don't inherit Azure-specific rules.
+        if _quirks.requires_cloud_account_auth:
             has_endpoint = bool(database.get("account_endpoint") or database.get("url"))
             if not has_endpoint:
                 raise ConfigurationError("Cosmos DB configuration requires account_endpoint or url")
@@ -842,15 +837,11 @@ class DbliftConfig:
             from config.secrets._registry import is_secret_uri as _is_secret_uri_args
 
             if not _is_secret_uri_args(url_val):
-                inferred_type = ""
-                url_lower = url_val.strip().lower()
-                if url_lower.startswith(("sqlite:", "sqlite3:")):
-                    inferred_type = "sqlite"  # lint: allow-dialect-string: URL-scheme inference (sqlite:// URL maps to sqlite type)
-                else:
-                    from db.provider_registry import ProviderRegistry
+                from db.provider_registry import ProviderRegistry
 
-                    scheme = url_lower.split(":", 1)[0].split("+", 1)[0]
-                    inferred_type = ProviderRegistry.canonical_dialect_name(scheme) or ""
+                url_lower = url_val.strip().lower()
+                scheme = url_lower.split(":", 1)[0].split("+", 1)[0]
+                inferred_type = ProviderRegistry.canonical_dialect_name(scheme) or ""
                 if inferred_type:
                     db_cfg["type"] = inferred_type
 

{dblift-2.0.4 → dblift-2.1.0}/core/constants.py

@@ -25,6 +25,15 @@ DB_DEPLOYMENT_ID_MAX_LENGTH = 100
 # package has to import the other.
 DBLIFT_SCHEMA_SNAPSHOTS_TABLE = "dblift_schema_snapshots"
 
+# Data sets / Lane B (audited corrections) managed tables.
+# The change-set table stores before/after row images using the snapshot codec.
+# Per-dataset history tables are named via config (e.g. dblift_data_history_corrections).
+DBLIFT_DATA_CHANGE_SET_TABLE = "dblift_data_change_set"
+
+# The audit table is an append-only, hash-chained log of apply/undo events,
+# shared across datasets (chained per-dataset). Tamper-evidence for the ledger.
+DBLIFT_DATA_AUDIT_TABLE = "dblift_data_audit"
+
 # Default timeout values
 DEFAULT_CONNECTION_TIMEOUT_SECONDS = 30
 DEFAULT_MIGRATION_LOCK_TIMEOUT_SECONDS = 60

{dblift-2.0.4 → dblift-2.1.0}/core/dialect_boundary.py

@@ -55,6 +55,7 @@ override only the deltas.
 
 from __future__ import annotations
 
+import re
 from typing import Any, Optional, Protocol, runtime_checkable
 
 
@@ -237,6 +238,29 @@ class TypeMapQuirks(Protocol):
         """Return dialect canonical→preferred type mapping."""
 
 
+@runtime_checkable
+class ErrorQuirks(Protocol):
+    """Error-classification hooks. Populated by ADR-26 T0."""
+
+    def error_patterns(self) -> "list[tuple[re.Pattern[str], Any]]":
+        """Return this dialect's ordered (compiled-regex, ErrorCategory) pairs
+        for connection/SQL error classification, or [] for none.
+
+        Typed loosely (second element is the db-layer ``ErrorCategory`` enum)
+        because this module is in ``core/`` and MUST NOT import from ``db/``
+        at module load — the core→db layering rule. Plugins return the
+        precise type."""
+
+
+@runtime_checkable
+class ConnectionQuirks(Protocol):
+    """Connection / engine-pool hooks. Populated by ADR-26 T0."""
+
+    def engine_pool_options(self) -> "dict[str, Any]":
+        """Return dialect-specific SQLAlchemy engine/pool kwargs merged into
+        ``create_engine(...)``. Default: {} (no overrides)."""
+
+
 @runtime_checkable
 class DialectQuirks(
     DdlQuirks,
@@ -245,6 +269,8 @@ class DialectQuirks(
     ComparatorQuirks,
     ValidatorQuirks,
     TypeMapQuirks,
+    ErrorQuirks,
+    ConnectionQuirks,
     Protocol,
 ):
     """Single contract for dialect-specific behaviour.
@@ -272,4 +298,6 @@ __all__ = [
     "ComparatorQuirks",
     "ValidatorQuirks",
     "TypeMapQuirks",
+    "ErrorQuirks",
+    "ConnectionQuirks",
 ]