dblift 2.3.0__tar.gz → 2.4.1__tar.gz

{dblift-2.3.0 → dblift-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.3.0
+Version: 2.4.1
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -69,6 +69,20 @@ Requires-Dist: ibm_db_sa>=0.4; extra == "db2"
 Provides-Extra: duckdb
 Requires-Dist: duckdb>=1.0; extra == "duckdb"
 Requires-Dist: duckdb_engine>=0.13; extra == "duckdb"
+Provides-Extra: neon
+Requires-Dist: psycopg[binary]>=3.1; extra == "neon"
+Provides-Extra: supabase
+Requires-Dist: psycopg[binary]>=3.1; extra == "supabase"
+Provides-Extra: aurora-postgresql
+Requires-Dist: psycopg[binary]>=3.1; extra == "aurora-postgresql"
+Provides-Extra: alloydb
+Requires-Dist: psycopg[binary]>=3.1; extra == "alloydb"
+Provides-Extra: yugabytedb
+Requires-Dist: psycopg[binary]>=3.1; extra == "yugabytedb"
+Provides-Extra: timescaledb
+Requires-Dist: psycopg[binary]>=3.1; extra == "timescaledb"
+Provides-Extra: citus
+Requires-Dist: psycopg[binary]>=3.1; extra == "citus"
 Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.100; extra == "fastapi"
 Provides-Extra: flask

{dblift-2.3.0 → dblift-2.4.1}/cli/_command_handlers.py

@@ -22,6 +22,7 @@ from cli.handlers.migrate import _handle_migrate
 from cli.handlers.repair import _handle_repair
 from cli.handlers.undo import _handle_undo
 from cli.handlers.validate import _handle_validate
+from core.seams.tier_resolver import resolve_tier
 
 _COMMAND_HANDLERS: Dict[str, Callable[[CliCommandContext], Tuple[bool, Any]]] = {
     "migrate": _handle_migrate,
@@ -72,6 +73,10 @@ def execute_single_command(
         recursive=recursive,
         placeholders=placeholders,
         dir_recursive_map=dir_recursive_map,
+        # Resolve the license tier through the seam so paid-feature gates
+        # (``require_tier(FEATURE, ctx.license_tier)``) see the real tier. In a
+        # pure-OSS install no resolver is registered and this is ``None``.
+        license_tier=resolve_tier(args),
     )
     return handler(ctx)
 

{dblift-2.3.0 → dblift-2.4.1}/cli/_config_helpers.py

@@ -3,7 +3,7 @@
 import argparse
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 from api._cli_support import ConnectionProvider
 from cli._parser_setup import create_parser, parse_with_selective_errors
@@ -70,12 +70,22 @@ def _extract_commands_from_argv(
     argv_list: List[str],
     available_commands: List[str],
     global_only_args: List[str],
+    global_boolean_flags: Optional[Iterable[str]] = None,
 ) -> Tuple[List[str], List[str], List[str]]:
     """Extract commands, global arguments, and subcommand arguments from argv.
 
+    ``global_boolean_flags`` names the global flags that take no value (so the
+    lookahead must not swallow the next token — usually a command name). It
+    defaults to the static :data:`_GLOBAL_BOOLEAN_FLAGS`; callers pass a
+    superset when dynamically-derived global flags (e.g. paid-extension
+    root-only flags) include boolean ones the static set can't see.
+
     Returns:
         Tuple of (commands, global_arguments, subcommand_args)
     """
+    boolean_flags = (
+        _GLOBAL_BOOLEAN_FLAGS if global_boolean_flags is None else frozenset(global_boolean_flags)
+    )
     commands = []
     global_arguments = []
     subcommand_args = []
@@ -103,7 +113,7 @@ def _extract_commands_from_argv(
 
         arg_name = safe_split_first(arg, "=", default=arg)
         is_global_only = arg_name in global_only_args
-        is_boolean_flag = arg_name in _GLOBAL_BOOLEAN_FLAGS
+        is_boolean_flag = arg_name in boolean_flags
 
         if is_global_only:
             global_arguments.append(arg)

{dblift-2.3.0 → dblift-2.4.1}/cli/main.py

@@ -1,9 +1,10 @@
 """Main CLI module for dblift."""
 
+import argparse
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Set
 
 # Add project root to Python path when running as a script
 # This allows imports to work when running: python3 cli/main.py
@@ -38,6 +39,7 @@ from cli._command_handlers import (  # noqa: F401
     execute_single_command,
 )
 from cli._config_helpers import (  # noqa: F401
+    _GLOBAL_BOOLEAN_FLAGS,
     _build_args_namespace,
     _close_logs,
     _collect_placeholders,
@@ -108,6 +110,49 @@ _GLOBAL_ONLY_ARGS: List[str] = [
     "--max-snapshots",
 ]
 
+
+def _root_only_long_flags(parser: argparse.ArgumentParser) -> Set[str]:
+    """Long flags defined only on the root parser, not on any subparser.
+
+    Paid extensions register their own root-only value flags on the parser
+    (``load_feature_extensions`` runs before the parser is built). Those flags
+    live only on the root parser, so — exactly like the static root-only flags
+    in ``_GLOBAL_ONLY_ARGS`` — the argv preprocessor must classify them as
+    global, or it relocates them past the subcommand token and the subparser
+    rejects them as "unrecognized arguments". Deriving them from the built
+    parser keeps the classification correct without the OSS core having to name
+    each extension flag. Mirrors the invariant asserted by
+    tests/unit/cli/test_global_only_args_completeness.py.
+    """
+    root = {o for a in parser._actions for o in a.option_strings if o.startswith("--")}
+    sub: Set[str] = set()
+    for action in parser._actions:
+        choices = getattr(action, "choices", None)
+        if isinstance(choices, dict):
+            for sub_parser in choices.values():
+                if isinstance(sub_parser, argparse.ArgumentParser):
+                    sub.update(
+                        o
+                        for a in sub_parser._actions
+                        for o in a.option_strings
+                        if o.startswith("--")
+                    )
+    return root - sub - {"--help"}
+
+
+def _root_only_boolean_flags(parser: argparse.ArgumentParser) -> Set[str]:
+    """Root-only long flags that take no value (``store_true``/``store_const``).
+
+    The argv preprocessor must know these so it does NOT run its value-lookahead
+    on them — otherwise the token after a boolean flag (typically a command
+    name) gets swallowed into the global bucket and the command is lost. The
+    static ``_GLOBAL_BOOLEAN_FLAGS`` covers OSS flags; this derives the same for
+    dynamically-discovered paid-extension boolean root flags.
+    """
+    root_only = _root_only_long_flags(parser)
+    return {o for a in parser._actions if a.nargs == 0 for o in a.option_strings if o in root_only}
+
+
 # Tool-level flag aliases for subcommands that take their own version-like
 # argument. Used by the B10-BUG-04 footgun guard in phase 1 to redirect
 # `dblift baseline --version 1.0.0` to the correct flag instead of
@@ -145,6 +190,44 @@ class _CliContext:
     license_info: Optional[Any] = None
 
 
+def _format_version() -> str:
+    """Render the ``--version`` output.
+
+    The published ``dblift`` wheel is the OSS *core*. The paid tiers ship as
+    separate distributions (``dblift-pro`` / ``dblift-enterprise``) bundled into
+    the compiled binary, each on its own release lifecycle — so their versions
+    need not match the core's. Report the most-derived installed tier as the
+    headline (that is the product the user actually runs) and, when a paid tier
+    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.
+    """
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _version
+
+    def _get(dist: str) -> Optional[str]:
+        try:
+            return _version(dist)
+        except PackageNotFoundError:
+            return None
+
+    core = _get("dblift")
+    pro = _get("dblift-pro")
+    enterprise = _get("dblift-enterprise")
+
+    # Headline = most-derived installed tier (the product actually running).
+    product = 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:
+        lines.append(f"  core (OSS):  {core}")
+        if pro:
+            lines.append(f"  pro:         {pro}")
+        if enterprise:
+            lines.append(f"  enterprise:  {enterprise}")
+    return "\n".join(lines)
+
+
 def main() -> None:
     """Main entry point for DBLift CLI application.
 
@@ -187,8 +270,19 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
     """
     terminal_commands = load_terminal_commands()
     available_commands = list(dict.fromkeys(_AVAILABLE_COMMANDS + list(terminal_commands)))
+    # Union the static root-only classification with root-only flags derived
+    # from the built parser, so paid-extension root flags (e.g. an
+    # override-the-license-file flag) are classified as global without the OSS
+    # core naming them. Boolean extension flags must also feed the splitter's
+    # boolean set, or its value-lookahead swallows the following command token.
+    # See _root_only_long_flags / _root_only_boolean_flags.
+    _parser = create_parser()
+    global_only_args = list(_GLOBAL_ONLY_ARGS) + sorted(
+        _root_only_long_flags(_parser) - set(_GLOBAL_ONLY_ARGS)
+    )
+    global_boolean_flags = set(_GLOBAL_BOOLEAN_FLAGS) | _root_only_boolean_flags(_parser)
     commands, global_arguments, subcommand_args = _extract_commands_from_argv(
-        argv, available_commands, _GLOBAL_ONLY_ARGS
+        argv, available_commands, global_only_args, global_boolean_flags
     )
 
     # B10-BUG-04: Flyway users type ``dblift baseline --version 1.0.0``
@@ -211,22 +305,14 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
     if commands and commands[0] in terminal_commands:
         args = _build_terminal_args(commands[0], global_arguments, subcommand_args)
         if hasattr(args, "version") and args.version:
-            from importlib.metadata import version as _version
-
-            __version__ = _version("dblift")
-
-            print(f"dblift version {__version__}")  # lint: allow-print  --version terminal action
+            print(_format_version())  # lint: allow-print  --version terminal action
             sys.exit(0)
         sys.exit(terminal_commands[commands[0]](args))
 
     args, _unknown_args = _build_args_namespace(commands, global_arguments, subcommand_args)
 
     if hasattr(args, "version") and args.version:
-        from importlib.metadata import version as _version
-
-        __version__ = _version("dblift")
-
-        print(f"dblift version {__version__}")  # lint: allow-print  --version terminal action
+        print(_format_version())  # lint: allow-print  --version terminal action
         sys.exit(0)
 
     if not commands and (not hasattr(args, "command") or not args.command):

dblift-2.4.1/db/plugins/alloydb/__init__.py

@@ -0,0 +1,12 @@
+"""Google AlloyDB for PostgreSQL database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "alloydb"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Google AlloyDB for PostgreSQL database provider"
+__plugin_dialects__ = ["alloydb"]
+__plugin_transport__ = "native"
+__plugin_class__ = "AlloydbProvider"
+
+from .provider import AlloydbProvider
+
+__all__ = ["AlloydbProvider"]

dblift-2.4.1/db/plugins/alloydb/plugin.py

@@ -0,0 +1,28 @@
+"""Entry-point declaration for the Google AlloyDB for PostgreSQL plugin.
+
+Google AlloyDB for PostgreSQL is wire-compatible with PostgreSQL: this plugin reuses PostgreSQL's
+config class (``config_dialect="postgresql"``), SQLAlchemy URL builder, and
+``psycopg`` driver, attaching only a distinct identity + quirks subclass. Users
+keep their ``postgresql://`` connection string and select this engine via
+``type: alloydb``.
+"""
+
+from __future__ import annotations
+
+from db.plugins.alloydb.provider import AlloydbProvider
+from db.plugins.alloydb.quirks import AlloydbQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="alloydb",
+    version="1.0.0",
+    description="Google AlloyDB for PostgreSQL database provider",
+    dialects=["alloydb"],
+    provider_class=AlloydbProvider,
+    transport="native",
+    quirks_class=AlloydbQuirks,
+    config_dialect="postgresql",  # Google AlloyDB for PostgreSQL shares PostgreSQL's config class
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="psycopg",
+)

dblift-2.4.1/db/plugins/alloydb/provider.py

@@ -0,0 +1,14 @@
+"""Google AlloyDB for PostgreSQL native provider (PostgreSQL-compatible)."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.provider import PostgreSqlProvider
+
+
+class AlloydbProvider(PostgreSqlProvider):
+    """Google AlloyDB for PostgreSQL — wire-compatible with PostgreSQL; reuses the PostgreSQL provider."""
+
+    canonical_dialect_key = "alloydb"
+
+
+__all__ = ["AlloydbProvider"]

dblift-2.4.1/db/plugins/alloydb/quirks.py

@@ -0,0 +1,32 @@
+"""Google AlloyDB for PostgreSQL :class:`DialectQuirks` — inherits PostgreSQL behavior."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+
+
+class AlloydbQuirks(PostgresqlQuirks):
+    """Google AlloyDB for PostgreSQL quirks, inheriting every PostgreSQL quirk.
+
+    Google AlloyDB for PostgreSQL speaks the PostgreSQL wire protocol, so statement splitting,
+    rendering, comparison, and introspection all reuse PostgreSQL's behavior.
+    Only the ANSI-reference flag is overridden: exactly one registered plugin
+    (PostgreSQL) may be the reference dialect, so PostgreSQL-derived plugins
+    must not re-claim it. Engine-specific deviations land here if and when the
+    codebase needs them.
+    """
+
+    # Exactly one plugin owns the ANSI reference dialect (PostgreSQL); a
+    # PG-derived plugin that inherited ``True`` would break
+    # ``ProviderRegistry.reference_dialect_name`` (which requires a single
+    # winner), so reset it here.
+    is_ansi_reference_dialect = False
+    # PostgreSQL is likewise the single owner of the sqlglot read-dialect
+    # fallback; a PG-derived plugin must not claim it either.
+    is_default_sqlglot_read_fallback = False
+
+    def __init__(self, dialect_name: str = "alloydb") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+
+__all__ = ["AlloydbQuirks"]

dblift-2.4.1/db/plugins/aurora_postgresql/__init__.py

@@ -0,0 +1,12 @@
+"""Amazon Aurora PostgreSQL database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "aurora-postgresql"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Amazon Aurora PostgreSQL database provider"
+__plugin_dialects__ = ["aurora-postgresql"]
+__plugin_transport__ = "native"
+__plugin_class__ = "AuroraPostgresqlProvider"
+
+from .provider import AuroraPostgresqlProvider
+
+__all__ = ["AuroraPostgresqlProvider"]

dblift-2.4.1/db/plugins/aurora_postgresql/plugin.py

@@ -0,0 +1,28 @@
+"""Entry-point declaration for the Amazon Aurora PostgreSQL plugin.
+
+Amazon Aurora PostgreSQL is wire-compatible with PostgreSQL: this plugin reuses PostgreSQL's
+config class (``config_dialect="postgresql"``), SQLAlchemy URL builder, and
+``psycopg`` driver, attaching only a distinct identity + quirks subclass. Users
+keep their ``postgresql://`` connection string and select this engine via
+``type: aurora-postgresql``.
+"""
+
+from __future__ import annotations
+
+from db.plugins.aurora_postgresql.provider import AuroraPostgresqlProvider
+from db.plugins.aurora_postgresql.quirks import AuroraPostgresqlQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="aurora-postgresql",
+    version="1.0.0",
+    description="Amazon Aurora PostgreSQL database provider",
+    dialects=["aurora-postgresql"],
+    provider_class=AuroraPostgresqlProvider,
+    transport="native",
+    quirks_class=AuroraPostgresqlQuirks,
+    config_dialect="postgresql",  # Amazon Aurora PostgreSQL shares PostgreSQL's config class
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="psycopg",
+)

dblift-2.4.1/db/plugins/aurora_postgresql/provider.py

@@ -0,0 +1,14 @@
+"""Amazon Aurora PostgreSQL native provider (PostgreSQL-compatible)."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.provider import PostgreSqlProvider
+
+
+class AuroraPostgresqlProvider(PostgreSqlProvider):
+    """Amazon Aurora PostgreSQL — wire-compatible with PostgreSQL; reuses the PostgreSQL provider."""
+
+    canonical_dialect_key = "aurora-postgresql"
+
+
+__all__ = ["AuroraPostgresqlProvider"]

dblift-2.4.1/db/plugins/aurora_postgresql/quirks.py

@@ -0,0 +1,32 @@
+"""Amazon Aurora PostgreSQL :class:`DialectQuirks` — inherits PostgreSQL behavior."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+
+
+class AuroraPostgresqlQuirks(PostgresqlQuirks):
+    """Amazon Aurora PostgreSQL quirks, inheriting every PostgreSQL quirk.
+
+    Amazon Aurora PostgreSQL speaks the PostgreSQL wire protocol, so statement splitting,
+    rendering, comparison, and introspection all reuse PostgreSQL's behavior.
+    Only the ANSI-reference flag is overridden: exactly one registered plugin
+    (PostgreSQL) may be the reference dialect, so PostgreSQL-derived plugins
+    must not re-claim it. Engine-specific deviations land here if and when the
+    codebase needs them.
+    """
+
+    # Exactly one plugin owns the ANSI reference dialect (PostgreSQL); a
+    # PG-derived plugin that inherited ``True`` would break
+    # ``ProviderRegistry.reference_dialect_name`` (which requires a single
+    # winner), so reset it here.
+    is_ansi_reference_dialect = False
+    # PostgreSQL is likewise the single owner of the sqlglot read-dialect
+    # fallback; a PG-derived plugin must not claim it either.
+    is_default_sqlglot_read_fallback = False
+
+    def __init__(self, dialect_name: str = "aurora-postgresql") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+
+__all__ = ["AuroraPostgresqlQuirks"]

dblift-2.4.1/db/plugins/citus/__init__.py

@@ -0,0 +1,12 @@
+"""Citus (distributed PostgreSQL) database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "citus"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Citus (distributed PostgreSQL) database provider"
+__plugin_dialects__ = ["citus"]
+__plugin_transport__ = "native"
+__plugin_class__ = "CitusProvider"
+
+from .provider import CitusProvider
+
+__all__ = ["CitusProvider"]

dblift-2.4.1/db/plugins/citus/plugin.py

@@ -0,0 +1,28 @@
+"""Entry-point declaration for the Citus (distributed PostgreSQL) plugin.
+
+Citus (distributed PostgreSQL) is wire-compatible with PostgreSQL: this plugin reuses PostgreSQL's
+config class (``config_dialect="postgresql"``), SQLAlchemy URL builder, and
+``psycopg`` driver, attaching only a distinct identity + quirks subclass. Users
+keep their ``postgresql://`` connection string and select this engine via
+``type: citus``.
+"""
+
+from __future__ import annotations
+
+from db.plugins.citus.provider import CitusProvider
+from db.plugins.citus.quirks import CitusQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="citus",
+    version="1.0.0",
+    description="Citus (distributed PostgreSQL) database provider",
+    dialects=["citus"],
+    provider_class=CitusProvider,
+    transport="native",
+    quirks_class=CitusQuirks,
+    config_dialect="postgresql",  # Citus (distributed PostgreSQL) shares PostgreSQL's config class
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="psycopg",
+)

dblift-2.4.1/db/plugins/citus/provider.py

@@ -0,0 +1,14 @@
+"""Citus (distributed PostgreSQL) native provider (PostgreSQL-compatible)."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.provider import PostgreSqlProvider
+
+
+class CitusProvider(PostgreSqlProvider):
+    """Citus (distributed PostgreSQL) — wire-compatible with PostgreSQL; reuses the PostgreSQL provider."""
+
+    canonical_dialect_key = "citus"
+
+
+__all__ = ["CitusProvider"]

dblift-2.4.1/db/plugins/citus/quirks.py

@@ -0,0 +1,32 @@
+"""Citus (distributed PostgreSQL) :class:`DialectQuirks` — inherits PostgreSQL behavior."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+
+
+class CitusQuirks(PostgresqlQuirks):
+    """Citus (distributed PostgreSQL) quirks, inheriting every PostgreSQL quirk.
+
+    Citus (distributed PostgreSQL) speaks the PostgreSQL wire protocol, so statement splitting,
+    rendering, comparison, and introspection all reuse PostgreSQL's behavior.
+    Only the ANSI-reference flag is overridden: exactly one registered plugin
+    (PostgreSQL) may be the reference dialect, so PostgreSQL-derived plugins
+    must not re-claim it. Engine-specific deviations land here if and when the
+    codebase needs them.
+    """
+
+    # Exactly one plugin owns the ANSI reference dialect (PostgreSQL); a
+    # PG-derived plugin that inherited ``True`` would break
+    # ``ProviderRegistry.reference_dialect_name`` (which requires a single
+    # winner), so reset it here.
+    is_ansi_reference_dialect = False
+    # PostgreSQL is likewise the single owner of the sqlglot read-dialect
+    # fallback; a PG-derived plugin must not claim it either.
+    is_default_sqlglot_read_fallback = False
+
+    def __init__(self, dialect_name: str = "citus") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+
+__all__ = ["CitusQuirks"]

dblift-2.4.1/db/plugins/neon/__init__.py

@@ -0,0 +1,12 @@
+"""Neon (serverless PostgreSQL) database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "neon"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Neon (serverless PostgreSQL) database provider"
+__plugin_dialects__ = ["neon"]
+__plugin_transport__ = "native"
+__plugin_class__ = "NeonProvider"
+
+from .provider import NeonProvider
+
+__all__ = ["NeonProvider"]

dblift-2.4.1/db/plugins/neon/plugin.py

@@ -0,0 +1,28 @@
+"""Entry-point declaration for the Neon (serverless PostgreSQL) plugin.
+
+Neon (serverless PostgreSQL) is wire-compatible with PostgreSQL: this plugin reuses PostgreSQL's
+config class (``config_dialect="postgresql"``), SQLAlchemy URL builder, and
+``psycopg`` driver, attaching only a distinct identity + quirks subclass. Users
+keep their ``postgresql://`` connection string and select this engine via
+``type: neon``.
+"""
+
+from __future__ import annotations
+
+from db.plugins.neon.provider import NeonProvider
+from db.plugins.neon.quirks import NeonQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="neon",
+    version="1.0.0",
+    description="Neon (serverless PostgreSQL) database provider",
+    dialects=["neon"],
+    provider_class=NeonProvider,
+    transport="native",
+    quirks_class=NeonQuirks,
+    config_dialect="postgresql",  # Neon (serverless PostgreSQL) shares PostgreSQL's config class
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="psycopg",
+)

dblift-2.4.1/db/plugins/neon/provider.py

@@ -0,0 +1,14 @@
+"""Neon (serverless PostgreSQL) native provider (PostgreSQL-compatible)."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.provider import PostgreSqlProvider
+
+
+class NeonProvider(PostgreSqlProvider):
+    """Neon (serverless PostgreSQL) — wire-compatible with PostgreSQL; reuses the PostgreSQL provider."""
+
+    canonical_dialect_key = "neon"
+
+
+__all__ = ["NeonProvider"]

dblift-2.4.1/db/plugins/neon/quirks.py

@@ -0,0 +1,32 @@
+"""Neon (serverless PostgreSQL) :class:`DialectQuirks` — inherits PostgreSQL behavior."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+
+
+class NeonQuirks(PostgresqlQuirks):
+    """Neon (serverless PostgreSQL) quirks, inheriting every PostgreSQL quirk.
+
+    Neon (serverless PostgreSQL) speaks the PostgreSQL wire protocol, so statement splitting,
+    rendering, comparison, and introspection all reuse PostgreSQL's behavior.
+    Only the ANSI-reference flag is overridden: exactly one registered plugin
+    (PostgreSQL) may be the reference dialect, so PostgreSQL-derived plugins
+    must not re-claim it. Engine-specific deviations land here if and when the
+    codebase needs them.
+    """
+
+    # Exactly one plugin owns the ANSI reference dialect (PostgreSQL); a
+    # PG-derived plugin that inherited ``True`` would break
+    # ``ProviderRegistry.reference_dialect_name`` (which requires a single
+    # winner), so reset it here.
+    is_ansi_reference_dialect = False
+    # PostgreSQL is likewise the single owner of the sqlglot read-dialect
+    # fallback; a PG-derived plugin must not claim it either.
+    is_default_sqlglot_read_fallback = False
+
+    def __init__(self, dialect_name: str = "neon") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+
+__all__ = ["NeonQuirks"]

{dblift-2.3.0 → dblift-2.4.1}/db/plugins/postgresql/config.py

@@ -15,9 +15,28 @@ class PostgreSqlConfig(BaseDatabaseConfig):
     # PostgreSQL specific attributes
     ssl_mode: Optional[str] = None
 
+    # PostgreSQL-compatible distributions share this config class via
+    # ``PluginInfo.config_dialect="postgresql"``. Membership here preserves their
+    # own ``type`` identity (mirrors MySQL/MariaDB's ``_MYSQL_FAMILY``); anything
+    # else — including the ``postgres`` alias — normalises to ``postgresql``.
+    # lint: allow-dialect-string: config family membership
+    _POSTGRESQL_FAMILY = frozenset(
+        {
+            "postgresql",
+            "neon",
+            "supabase",
+            "aurora-postgresql",
+            "alloydb",
+            "yugabytedb",
+            "timescaledb",
+            "citus",
+        }
+    )
+
     def __post_init__(self) -> None:
         super().__post_init__()
-        self.type = "postgresql"  # lint: allow-dialect-string: config type identity
+        if self.type not in self._POSTGRESQL_FAMILY:
+            self.type = "postgresql"  # lint: allow-dialect-string: config type identity
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary with PostgreSQL specific parameters."""

dblift-2.4.1/db/plugins/supabase/__init__.py

@@ -0,0 +1,12 @@
+"""Supabase (PostgreSQL) database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "supabase"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Supabase (PostgreSQL) database provider"
+__plugin_dialects__ = ["supabase"]
+__plugin_transport__ = "native"
+__plugin_class__ = "SupabaseProvider"
+
+from .provider import SupabaseProvider
+
+__all__ = ["SupabaseProvider"]