sqlspec 0.18.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

sqlspec/base.py

@@ -593,22 +593,18 @@ class SQLSpec:
             )
         )
 
-    def _ensure_sql_loader(self) -> "SQLFileLoader":
-        """Ensure SQL loader is initialized lazily."""
-        if self._sql_loader is None:
-            from sqlspec.loader import SQLFileLoader
-
-            self._sql_loader = SQLFileLoader()
-        return self._sql_loader
-
     def load_sql_files(self, *paths: "Union[str, Path]") -> None:
         """Load SQL files from paths or directories.
 
         Args:
             *paths: One or more file paths or directory paths to load.
         """
-        loader = self._ensure_sql_loader()
-        loader.load_sql(*paths)
+        if self._sql_loader is None:
+            from sqlspec.loader import SQLFileLoader
+
+            self._sql_loader = SQLFileLoader()
+
+        self._sql_loader.load_sql(*paths)
         logger.debug("Loaded SQL files: %s", paths)
 
     def add_named_sql(self, name: str, sql: str, dialect: "Optional[str]" = None) -> None:
@@ -619,8 +615,12 @@ class SQLSpec:
             sql: Raw SQL content.
             dialect: Optional dialect for the SQL statement.
         """
-        loader = self._ensure_sql_loader()
-        loader.add_named_sql(name, sql, dialect)
+        if self._sql_loader is None:
+            from sqlspec.loader import SQLFileLoader
+
+            self._sql_loader = SQLFileLoader()
+
+        self._sql_loader.add_named_sql(name, sql, dialect)
         logger.debug("Added named SQL: %s", name)
 
     def get_sql(self, name: str) -> "SQL":
@@ -633,8 +633,12 @@ class SQLSpec:
         Returns:
             SQL object ready for execution.
         """
-        loader = self._ensure_sql_loader()
-        return loader.get_sql(name)
+        if self._sql_loader is None:
+            from sqlspec.loader import SQLFileLoader
+
+            self._sql_loader = SQLFileLoader()
+
+        return self._sql_loader.get_sql(name)
 
     def list_sql_queries(self) -> "list[str]":
         """List all available query names.

sqlspec/cli.py

@@ -1,3 +1,4 @@
+# ruff: noqa: C901
 import sys
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
@@ -99,6 +100,15 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         show_default=True,
         is_flag=True,
     )
+    include_option = click.option(
+        "--include", multiple=True, help="Include only specific configurations (can be used multiple times)"
+    )
+    exclude_option = click.option(
+        "--exclude", multiple=True, help="Exclude specific configurations (can be used multiple times)"
+    )
+    dry_run_option = click.option(
+        "--dry-run", is_flag=True, default=False, help="Show what would be executed without making changes"
+    )
 
     def get_config_by_bind_key(
         ctx: "click.Context", bind_key: Optional[str]
@@ -114,35 +124,180 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         """
         configs = ctx.obj["configs"]
         if bind_key is None:
-            return cast("Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]", configs[0])
+            config = configs[0]
+        else:
+            config = None
+            for cfg in configs:
+                config_name = getattr(cfg, "name", None) or getattr(cfg, "bind_key", None)
+                if config_name == bind_key:
+                    config = cfg
+                    break
+
+            if config is None:
+                console.print(f"[red]No config found for bind key: {bind_key}[/]")
+                sys.exit(1)
+
+        # Extract the actual config from DatabaseConfig wrapper if needed
+        from sqlspec.extensions.litestar.config import DatabaseConfig
+
+        if isinstance(config, DatabaseConfig):
+            config = config.config
+
+        return cast("Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]", config)
+
+    def get_configs_with_migrations(ctx: "click.Context", enabled_only: bool = False) -> "list[tuple[str, Any]]":
+        """Get all configurations that have migrations enabled.
+
+        Args:
+            ctx: The click context.
+            enabled_only: If True, only return configs with enabled=True.
+
+        Returns:
+            List of tuples (config_name, config) for configs with migrations enabled.
+        """
+        configs = ctx.obj["configs"]
+        migration_configs = []
+
+        from sqlspec.extensions.litestar.config import DatabaseConfig
 
         for config in configs:
-            config_name = getattr(config, "name", None) or getattr(config, "bind_key", None)
-            if config_name == bind_key:
-                return cast("Union[AsyncDatabaseConfig[Any, Any, Any], SyncDatabaseConfig[Any, Any, Any]]", config)
+            # Extract the actual config from DatabaseConfig wrapper if needed
+            actual_config = config.config if isinstance(config, DatabaseConfig) else config
+
+            migration_config = getattr(actual_config, "migration_config", None)
+            if migration_config:
+                enabled = migration_config.get("enabled", True)
+                if not enabled_only or enabled:
+                    config_name = (
+                        getattr(actual_config, "name", None)
+                        or getattr(actual_config, "bind_key", None)
+                        or str(type(actual_config).__name__)
+                    )
+                    migration_configs.append((config_name, actual_config))
+
+        return migration_configs
+
+    def filter_configs(
+        configs: "list[tuple[str, Any]]", include: "tuple[str, ...]", exclude: "tuple[str, ...]"
+    ) -> "list[tuple[str, Any]]":
+        """Filter configuration list based on include/exclude criteria.
+
+        Args:
+            configs: List of (config_name, config) tuples.
+            include: Config names to include (empty means include all).
+            exclude: Config names to exclude.
+
+        Returns:
+            Filtered list of configurations.
+        """
+        filtered = configs
+        if include:
+            filtered = [(name, config) for name, config in filtered if name in include]
+        if exclude:
+            filtered = [(name, config) for name, config in filtered if name not in exclude]
+        return filtered
+
+    def process_multiple_configs(
+        ctx: "click.Context",
+        bind_key: Optional[str],
+        include: "tuple[str, ...]",
+        exclude: "tuple[str, ...]",
+        dry_run: bool,
+        operation_name: str,
+    ) -> "Optional[list[tuple[str, Any]]]":
+        """Process configuration selection for multi-config operations.
+
+        Args:
+            ctx: Click context.
+            bind_key: Specific bind key to target.
+            include: Config names to include.
+            exclude: Config names to exclude.
+            dry_run: Whether this is a dry run.
+            operation_name: Name of the operation for display.
+
+        Returns:
+            List of (config_name, config) tuples to process, or None for single config mode.
+        """
+        # If specific bind_key requested, use single config mode
+        if bind_key and not include and not exclude:
+            return None
+
+        # Get enabled configs by default, all configs if include/exclude specified
+        enabled_only = not include and not exclude
+        migration_configs = get_configs_with_migrations(ctx, enabled_only=enabled_only)
+
+        # If only one config and no filtering, use single config mode
+        if len(migration_configs) <= 1 and not include and not exclude:
+            return None
+
+        # Apply filtering
+        configs_to_process = filter_configs(migration_configs, include, exclude)
+
+        if not configs_to_process:
+            console.print("[yellow]No configurations match the specified criteria.[/]")
+            return []
 
-        console.print(f"[red]No config found for bind key: {bind_key}[/]")
-        sys.exit(1)
+        # Show what will be processed
+        if dry_run:
+            console.print(f"[blue]Dry run: Would {operation_name} {len(configs_to_process)} configuration(s)[/]")
+            for config_name, _ in configs_to_process:
+                console.print(f"  • {config_name}")
+            return []
+
+        return configs_to_process
 
     @database_group.command(name="show-current-revision", help="Shows the current revision for the database.")
     @bind_key_option
     @verbose_option
-    def show_database_revision(bind_key: Optional[str], verbose: bool) -> None:  # pyright: ignore[reportUnusedFunction]
+    @include_option
+    @exclude_option
+    def show_database_revision(  # pyright: ignore[reportUnusedFunction]
+        bind_key: Optional[str], verbose: bool, include: "tuple[str, ...]", exclude: "tuple[str, ...]"
+    ) -> None:
         """Show current database revision."""
         from sqlspec.migrations.commands import MigrationCommands
 
         ctx = click.get_current_context()
-        console.rule("[yellow]Listing current revision[/]", align="left")
-        sqlspec_config = get_config_by_bind_key(ctx, bind_key)
-        migration_commands = MigrationCommands(config=sqlspec_config)
-        migration_commands.current(verbose=verbose)
+
+        # Check if this is a multi-config operation
+        configs_to_process = process_multiple_configs(
+            ctx, bind_key, include, exclude, dry_run=False, operation_name="show current revision"
+        )
+
+        if configs_to_process is not None:
+            if not configs_to_process:
+                return
+
+            console.rule("[yellow]Listing current revisions for all configurations[/]", align="left")
+
+            for config_name, config in configs_to_process:
+                console.print(f"\n[blue]Configuration: {config_name}[/]")
+                try:
+                    migration_commands = MigrationCommands(config=config)
+                    migration_commands.current(verbose=verbose)
+                except Exception as e:
+                    console.print(f"[red]✗ Failed to get current revision for {config_name}: {e}[/]")
+        else:
+            # Single config operation
+            console.rule("[yellow]Listing current revision[/]", align="left")
+            sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+            migration_commands = MigrationCommands(config=sqlspec_config)
+            migration_commands.current(verbose=verbose)
 
     @database_group.command(name="downgrade", help="Downgrade database to a specific revision.")
     @bind_key_option
     @no_prompt_option
+    @include_option
+    @exclude_option
+    @dry_run_option
     @click.argument("revision", type=str, default="-1")
     def downgrade_database(  # pyright: ignore[reportUnusedFunction]
-        bind_key: Optional[str], revision: str, no_prompt: bool
+        bind_key: Optional[str],
+        revision: str,
+        no_prompt: bool,
+        include: "tuple[str, ...]",
+        exclude: "tuple[str, ...]",
+        dry_run: bool,
     ) -> None:
         """Downgrade the database to the latest revision."""
         from rich.prompt import Confirm
@@ -150,23 +305,59 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         from sqlspec.migrations.commands import MigrationCommands
 
         ctx = click.get_current_context()
-        console.rule("[yellow]Starting database downgrade process[/]", align="left")
-        input_confirmed = (
-            True
-            if no_prompt
-            else Confirm.ask(f"Are you sure you want to downgrade the database to the `{revision}` revision?")
+
+        # Check if this is a multi-config operation
+        configs_to_process = process_multiple_configs(
+            ctx, bind_key, include, exclude, dry_run=dry_run, operation_name=f"downgrade to {revision}"
         )
-        if input_confirmed:
-            sqlspec_config = get_config_by_bind_key(ctx, bind_key)
-            migration_commands = MigrationCommands(config=sqlspec_config)
-            migration_commands.downgrade(revision=revision)
+
+        if configs_to_process is not None:
+            if not configs_to_process:
+                return
+
+            if not no_prompt and not Confirm.ask(
+                f"[bold]Are you sure you want to downgrade {len(configs_to_process)} configuration(s) to revision {revision}?[/]"
+            ):
+                console.print("[yellow]Operation cancelled.[/]")
+                return
+
+            console.rule("[yellow]Starting multi-configuration downgrade process[/]", align="left")
+
+            for config_name, config in configs_to_process:
+                console.print(f"[blue]Downgrading configuration: {config_name}[/]")
+                try:
+                    migration_commands = MigrationCommands(config=config)
+                    migration_commands.downgrade(revision=revision)
+                    console.print(f"[green]✓ Successfully downgraded: {config_name}[/]")
+                except Exception as e:
+                    console.print(f"[red]✗ Failed to downgrade {config_name}: {e}[/]")
+        else:
+            # Single config operation
+            console.rule("[yellow]Starting database downgrade process[/]", align="left")
+            input_confirmed = (
+                True
+                if no_prompt
+                else Confirm.ask(f"Are you sure you want to downgrade the database to the `{revision}` revision?")
+            )
+            if input_confirmed:
+                sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+                migration_commands = MigrationCommands(config=sqlspec_config)
+                migration_commands.downgrade(revision=revision)
 
     @database_group.command(name="upgrade", help="Upgrade database to a specific revision.")
     @bind_key_option
     @no_prompt_option
+    @include_option
+    @exclude_option
+    @dry_run_option
     @click.argument("revision", type=str, default="head")
     def upgrade_database(  # pyright: ignore[reportUnusedFunction]
-        bind_key: Optional[str], revision: str, no_prompt: bool
+        bind_key: Optional[str],
+        revision: str,
+        no_prompt: bool,
+        include: "tuple[str, ...]",
+        exclude: "tuple[str, ...]",
+        dry_run: bool,
     ) -> None:
         """Upgrade the database to the latest revision."""
         from rich.prompt import Confirm
@@ -174,16 +365,44 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         from sqlspec.migrations.commands import MigrationCommands
 
         ctx = click.get_current_context()
-        console.rule("[yellow]Starting database upgrade process[/]", align="left")
-        input_confirmed = (
-            True
-            if no_prompt
-            else Confirm.ask(f"[bold]Are you sure you want migrate the database to the `{revision}` revision?[/]")
+
+        # Check if this is a multi-config operation
+        configs_to_process = process_multiple_configs(
+            ctx, bind_key, include, exclude, dry_run, operation_name=f"upgrade to {revision}"
         )
-        if input_confirmed:
-            sqlspec_config = get_config_by_bind_key(ctx, bind_key)
-            migration_commands = MigrationCommands(config=sqlspec_config)
-            migration_commands.upgrade(revision=revision)
+
+        if configs_to_process is not None:
+            if not configs_to_process:
+                return
+
+            if not no_prompt and not Confirm.ask(
+                f"[bold]Are you sure you want to upgrade {len(configs_to_process)} configuration(s) to revision {revision}?[/]"
+            ):
+                console.print("[yellow]Operation cancelled.[/]")
+                return
+
+            console.rule("[yellow]Starting multi-configuration upgrade process[/]", align="left")
+
+            for config_name, config in configs_to_process:
+                console.print(f"[blue]Upgrading configuration: {config_name}[/]")
+                try:
+                    migration_commands = MigrationCommands(config=config)
+                    migration_commands.upgrade(revision=revision)
+                    console.print(f"[green]✓ Successfully upgraded: {config_name}[/]")
+                except Exception as e:
+                    console.print(f"[red]✗ Failed to upgrade {config_name}: {e}[/]")
+        else:
+            # Single config operation
+            console.rule("[yellow]Starting database upgrade process[/]", align="left")
+            input_confirmed = (
+                True
+                if no_prompt
+                else Confirm.ask(f"[bold]Are you sure you want migrate the database to the `{revision}` revision?[/]")
+            )
+            if input_confirmed:
+                sqlspec_config = get_config_by_bind_key(ctx, bind_key)
+                migration_commands = MigrationCommands(config=sqlspec_config)
+                migration_commands.upgrade(revision=revision)
 
     @database_group.command(help="Stamp the revision table with the given revision")
     @click.argument("revision", type=str)
@@ -217,10 +436,14 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         )
         if input_confirmed:
             configs = [get_config_by_bind_key(ctx, bind_key)] if bind_key is not None else ctx.obj["configs"]
+            from sqlspec.extensions.litestar.config import DatabaseConfig
+
             for config in configs:
-                migration_config = getattr(config, "migration_config", {})
+                # Extract the actual config from DatabaseConfig wrapper if needed
+                actual_config = config.config if isinstance(config, DatabaseConfig) else config
+                migration_config = getattr(actual_config, "migration_config", {})
                 directory = migration_config.get("script_location", "migrations") if directory is None else directory
-                migration_commands = MigrationCommands(config=config)
+                migration_commands = MigrationCommands(config=actual_config)
                 migration_commands.init(directory=cast("str", directory), package=package)
 
     @database_group.command(name="make-migrations", help="Create a new migration revision.")
@@ -244,4 +467,29 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         migration_commands = MigrationCommands(config=sqlspec_config)
         migration_commands.revision(message=message)
 
+    @database_group.command(name="show-config", help="Show all configurations with migrations enabled.")
+    def show_config() -> None:  # pyright: ignore[reportUnusedFunction]
+        """Show and display all configurations with migrations enabled."""
+        from rich.table import Table
+
+        ctx = click.get_current_context()
+        migration_configs = get_configs_with_migrations(ctx)
+
+        if not migration_configs:
+            console.print("[yellow]No configurations with migrations detected.[/]")
+            return
+
+        table = Table(title="Migration Configurations")
+        table.add_column("Configuration Name", style="cyan")
+        table.add_column("Migration Path", style="blue")
+        table.add_column("Status", style="green")
+
+        for config_name, config in migration_configs:
+            migration_config = getattr(config, "migration_config", {})
+            script_location = migration_config.get("script_location", "migrations")
+            table.add_row(config_name, script_location, "Migration Enabled")
+
+        console.print(table)
+        console.print(f"[blue]Found {len(migration_configs)} configuration(s) with migrations enabled.[/]")
+
     return database_group

sqlspec/config.py

@@ -11,8 +11,11 @@ from sqlspec.utils.logging import get_logger
 if TYPE_CHECKING:
     from collections.abc import Awaitable
     from contextlib import AbstractAsyncContextManager, AbstractContextManager
+    from pathlib import Path
 
     from sqlspec.driver import AsyncDriverAdapterBase, SyncDriverAdapterBase
+    from sqlspec.loader import SQLFileLoader
+    from sqlspec.migrations.commands import MigrationCommands
 
 
 __all__ = (
@@ -76,11 +79,24 @@ class MigrationConfig(TypedDict, total=False):
     project_root: NotRequired[str]
     """Path to the project root directory. Used for relative path resolution."""
 
+    enabled: NotRequired[bool]
+    """Whether this configuration should be included in CLI operations. Defaults to True."""
+
 
 class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
     """Protocol defining the interface for database configurations."""
 
-    __slots__ = ("driver_features", "migration_config", "pool_instance", "statement_config")
+    __slots__ = (
+        "_migration_commands",
+        "_migration_loader",
+        "driver_features",
+        "migration_config",
+        "pool_instance",
+        "statement_config",
+    )
+
+    _migration_loader: "SQLFileLoader"
+    _migration_commands: "MigrationCommands"
     driver_type: "ClassVar[type[Any]]"
     connection_type: "ClassVar[type[Any]]"
     is_async: "ClassVar[bool]" = False
@@ -153,6 +169,136 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
         """
         return {}
 
+    def _initialize_migration_components(self) -> None:
+        """Initialize migration loader and commands with necessary imports.
+
+        This method handles the circular import between config and commands
+        by importing at runtime when needed.
+        """
+        from sqlspec.loader import SQLFileLoader
+        from sqlspec.migrations.commands import MigrationCommands
+
+        self._migration_loader = SQLFileLoader()
+        self._migration_commands = MigrationCommands(self)  # type: ignore[arg-type]
+
+    def _ensure_migration_loader(self) -> "SQLFileLoader":
+        """Get the migration SQL loader and auto-load files if needed.
+
+        Returns:
+            The SQLFileLoader instance for migration files.
+        """
+        # Auto-load migration files from configured migration path if it exists
+        migration_config = self.migration_config or {}
+        script_location = migration_config.get("script_location", "migrations")
+
+        from pathlib import Path
+
+        migration_path = Path(script_location)
+        if migration_path.exists() and not self._migration_loader.list_files():
+            self._migration_loader.load_sql(migration_path)
+            logger.debug("Auto-loaded migration SQL files from %s", migration_path)
+
+        return self._migration_loader
+
+    def _ensure_migration_commands(self) -> "MigrationCommands":
+        """Get the migration commands instance.
+
+        Returns:
+            The MigrationCommands instance for this config.
+        """
+        return self._migration_commands
+
+    def get_migration_loader(self) -> "SQLFileLoader":
+        """Get the SQL loader for migration files.
+
+        This provides access to migration SQL files loaded from the configured
+        script_location directory. Files are loaded lazily on first access.
+
+        Returns:
+            SQLFileLoader instance with migration files loaded.
+        """
+        return self._ensure_migration_loader()
+
+    def load_migration_sql_files(self, *paths: "Union[str, Path]") -> None:
+        """Load additional migration SQL files from specified paths.
+
+        Args:
+            *paths: One or more file paths or directory paths to load migration SQL files from.
+        """
+        from pathlib import Path
+
+        loader = self._ensure_migration_loader()
+        for path in paths:
+            path_obj = Path(path)
+            if path_obj.exists():
+                loader.load_sql(path_obj)
+                logger.debug("Loaded migration SQL files from %s", path_obj)
+            else:
+                logger.warning("Migration path does not exist: %s", path_obj)
+
+    def get_migration_commands(self) -> "MigrationCommands":
+        """Get migration commands for this configuration.
+
+        Returns:
+            MigrationCommands instance configured for this database.
+        """
+        return self._ensure_migration_commands()
+
+    def migrate_up(self, revision: str = "head") -> None:
+        """Apply migrations up to the specified revision.
+
+        Args:
+            revision: Target revision or "head" for latest. Defaults to "head".
+        """
+        commands = self._ensure_migration_commands()
+        commands.upgrade(revision)
+
+    def migrate_down(self, revision: str = "-1") -> None:
+        """Apply migrations down to the specified revision.
+
+        Args:
+            revision: Target revision, "-1" for one step back, or "base" for all migrations. Defaults to "-1".
+        """
+        commands = self._ensure_migration_commands()
+        commands.downgrade(revision)
+
+    def get_current_migration(self, verbose: bool = False) -> "Optional[str]":
+        """Get the current migration version.
+
+        Args:
+            verbose: Whether to show detailed migration history.
+
+        Returns:
+            The current migration version or None if no migrations applied.
+        """
+        commands = self._ensure_migration_commands()
+        return commands.current(verbose=verbose)
+
+    def create_migration(self, message: str, file_type: str = "sql") -> None:
+        """Create a new migration file.
+
+        Args:
+            message: Description for the migration.
+            file_type: Type of migration file to create ('sql' or 'py'). Defaults to 'sql'.
+        """
+        commands = self._ensure_migration_commands()
+        commands.revision(message, file_type)
+
+    def init_migrations(self, directory: "Optional[str]" = None, package: bool = True) -> None:
+        """Initialize migration directory structure.
+
+        Args:
+            directory: Directory to initialize migrations in. Uses script_location from migration_config if not provided.
+            package: Whether to create __init__.py file. Defaults to True.
+        """
+        if directory is None:
+            migration_config = self.migration_config or {}
+            directory = migration_config.get("script_location") or "migrations"
+
+        commands = self._ensure_migration_commands()
+        assert directory is not None
+        commands.init(directory, package)
+
 
 class NoPoolSyncConfig(DatabaseConfigProtocol[ConnectionT, None, DriverT]):
     """Base class for a sync database configurations that do not implement a pool."""
@@ -173,6 +319,7 @@ class NoPoolSyncConfig(DatabaseConfigProtocol[ConnectionT, None, DriverT]):
         self.pool_instance = None
         self.connection_config = connection_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}
+        self._initialize_migration_components()
 
         if statement_config is None:
             default_parameter_config = ParameterStyleConfig(
@@ -226,6 +373,7 @@ class NoPoolAsyncConfig(DatabaseConfigProtocol[ConnectionT, None, DriverT]):
         self.pool_instance = None
         self.connection_config = connection_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}
+        self._initialize_migration_components()
 
         if statement_config is None:
             default_parameter_config = ParameterStyleConfig(
@@ -280,6 +428,7 @@ class SyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]):
         self.pool_instance = pool_instance
         self.pool_config = pool_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}
+        self._initialize_migration_components()
 
         if statement_config is None:
             default_parameter_config = ParameterStyleConfig(
@@ -356,6 +505,7 @@ class AsyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]):
         self.pool_instance = pool_instance
         self.pool_config = pool_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}
+        self._initialize_migration_components()
 
         if statement_config is None:
             self.statement_config = StatementConfig(

sqlspec/extensions/litestar/plugin.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from litestar.di import Provide
 from litestar.plugins import CLIPlugin, InitPluginProtocol
@@ -14,23 +14,31 @@ if TYPE_CHECKING:
     from click import Group
     from litestar.config.app import AppConfig
 
+    from sqlspec.loader import SQLFileLoader
+
 logger = get_logger("extensions.litestar")
 
 
-class SQLSpec(InitPluginProtocol, CLIPlugin, SQLSpecBase):
+class SQLSpec(SQLSpecBase, InitPluginProtocol, CLIPlugin):
     """Litestar plugin for SQLSpec database integration."""
 
-    __slots__ = ("_config", "_plugin_configs")
+    __slots__ = ("_plugin_configs",)
 
-    def __init__(self, config: Union["SyncConfigT", "AsyncConfigT", "DatabaseConfig", list["DatabaseConfig"]]) -> None:
+    def __init__(
+        self,
+        config: Union["SyncConfigT", "AsyncConfigT", "DatabaseConfig", list["DatabaseConfig"]],
+        *,
+        loader: "Optional[SQLFileLoader]" = None,
+    ) -> None:
         """Initialize SQLSpec plugin.
 
         Args:
             config: Database configuration for SQLSpec plugin.
+            loader: Optional SQL file loader instance.
         """
-        self._configs: dict[Any, DatabaseConfigProtocol[Any, Any, Any]] = {}
+        super().__init__(loader=loader)
         if isinstance(config, DatabaseConfigProtocol):
-            self._plugin_configs: list[DatabaseConfig] = [DatabaseConfig(config=config)]
+            self._plugin_configs: list[DatabaseConfig] = [DatabaseConfig(config=config)]  # pyright: ignore
         elif isinstance(config, DatabaseConfig):
             self._plugin_configs = [config]
         else:
@@ -83,8 +91,7 @@ class SQLSpec(InitPluginProtocol, CLIPlugin, SQLSpecBase):
             app_config.signature_types.append(c.config.connection_type)  # type: ignore[union-attr]
             app_config.signature_types.append(c.config.driver_type)  # type: ignore[union-attr]
 
-            if hasattr(c.config, "get_signature_namespace"):
-                signature_namespace.update(c.config.get_signature_namespace())  # type: ignore[attr-defined]
+            signature_namespace.update(c.config.get_signature_namespace())  # type: ignore[union-attr]
 
             app_config.before_send.append(c.before_send_handler)
             app_config.lifespan.append(c.lifespan_handler)  # pyright: ignore[reportUnknownMemberType]

{sqlspec-0.18.0.dist-info → sqlspec-0.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.18.0
+Version: 0.19.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.18.0.dist-info → sqlspec-0.19.0.dist-info}/RECORD

@@ -4,9 +4,9 @@ sqlspec/__metadata__.py,sha256=IUw6MCTy1oeUJ1jAVYbuJLkOWbiAWorZ5W-E-SAD9N4,395
 sqlspec/_serialization.py,sha256=6U5-smk2h2yl0i6am2prtOLJTdu4NJQdcLlSfSUMaUQ,2590
 sqlspec/_sql.py,sha256=j9WljOgCme4jTfL6NegEWOhK-Rr3JEmhtbneh8ZN1bQ,45221
 sqlspec/_typing.py,sha256=jv-7QHGLrJLfnP86bR-Xcmj3PDoddNZEKDz_vYRBiAU,22684
-sqlspec/base.py,sha256=-5hxBpjEvbn30aXksbErkw3lH0Q3-u7h6D2JB9BSAmU,25429
-sqlspec/cli.py,sha256=3ZxPwl4neNWyrAkM9J9ccC_gaFigDJbhuZfx15JVE7E,9903
-sqlspec/config.py,sha256=QJMR46YC-6Kd4GUnqQm0s679Br4R-QEEruuKpJxHEec,15969
+sqlspec/base.py,sha256=ajQUBYz2NhDFZ8cMJ2nSNuNWT73mfRcaId08n74YR88,25468
+sqlspec/cli.py,sha256=Fe5Wbnrb_fkE9qm4gbBEXx3d0Q7VR-S-1t76ouAx2mg,20120
+sqlspec/config.py,sha256=cQGBxaUACaiIhhZ9GOQ6DvNMsrVowR212_13gHdLMvc,21620
 sqlspec/exceptions.py,sha256=zBnzQOfYAgqX04GoaC9Io6ardzinldkEuZ3YtR5vr9U,6071
 sqlspec/loader.py,sha256=HDfMZDj7l9aLAxeZR2Rv-HC-dWah4CPkwZ6HKQ7yP-Y,23398
 sqlspec/protocols.py,sha256=Of6uJyxvawExCEyR3u7jbxOckUcwG0HHOEXmfHyev40,13106
@@ -103,7 +103,7 @@ sqlspec/extensions/litestar/_utils.py,sha256=o-FuUj1_WkDrLxQxiP6hXDak66XfyRP3QLy
 sqlspec/extensions/litestar/cli.py,sha256=X4DlAx3Ry-ccOjAQSxe8SMtyJKCFJVLTbENPU_efKuU,1356
 sqlspec/extensions/litestar/config.py,sha256=3UI_vhtbupCLsf1nhUgUpRlCoUS5c0GsAjWvegT0c3c,4462
 sqlspec/extensions/litestar/handlers.py,sha256=3LreU8rZvuHaJnKlN09ttu4wSorWJedsuKgeLT-cOEc,9993
-sqlspec/extensions/litestar/plugin.py,sha256=I0aRnL4oZPUYk7pYhZSL3yikl7ViM0kr33kVmH4W-MU,5637
+sqlspec/extensions/litestar/plugin.py,sha256=u4Mjq16EYb4oxzbONCLdQY2P40Po-e8wQXnVnJKXGCA,5732
 sqlspec/extensions/litestar/providers.py,sha256=5LRb5JvRV_XZdNOKkdaIy3j5x-dFCcAi1ea1pgwuapI,18882
 sqlspec/migrations/__init__.py,sha256=RiDi_HkUIgXtu_33QnRdvYNqcCn-euHUiWwTiPr5IGc,1055
 sqlspec/migrations/base.py,sha256=vIzQzUtQrNKDec6XUeRHcCBuWU1KNtRCFpOvVxsp3sQ,13093
@@ -130,9 +130,9 @@ sqlspec/utils/singleton.py,sha256=SKnszJi1NPeERgX7IjVIGYAYx4XqR1E_rph3bU6olAU,10
 sqlspec/utils/sync_tools.py,sha256=f_bjHTXUaDcsNQY63-L7j5xn2MHfzXro-ShzJM-WLUI,8356
 sqlspec/utils/text.py,sha256=W97aX77A3NzG795AHjhdX6zqOBDmvLaXLCno2JIugCo,3081
 sqlspec/utils/type_guards.py,sha256=9C4SRebO4JiQrMzcJZFUA0KjSU48G26RmX6lbijyjBg,30476
-sqlspec-0.18.0.dist-info/METADATA,sha256=SNUm1W2FagyGjCmPrfUcCNBRSyurCMbg60IUMf9iA1E,16822
-sqlspec-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlspec-0.18.0.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
-sqlspec-0.18.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
-sqlspec-0.18.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
-sqlspec-0.18.0.dist-info/RECORD,,
+sqlspec-0.19.0.dist-info/METADATA,sha256=ax4hmcjtDgGFAQWuE3lw25tqBX-EkByjo0t3H-xnkrg,16822
+sqlspec-0.19.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.19.0.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
+sqlspec-0.19.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.19.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.19.0.dist-info/RECORD,,