sqlspec 0.24.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

sqlspec/cli.py

@@ -1,6 +1,8 @@
 # ruff: noqa: C901
+import inspect
 import sys
 from collections.abc import Sequence
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 if TYPE_CHECKING:
@@ -33,28 +35,56 @@ def get_sqlspec_group() -> "Group":
     @click.group(name="sqlspec")
     @click.option(
         "--config",
-        help="Dotted path to SQLSpec config(s) (e.g. 'myapp.config.sqlspec_configs')",
+        help="Dotted path to SQLSpec config(s) or callable function (e.g. 'myapp.config.get_configs')",
         required=True,
         type=str,
     )
+    @click.option(
+        "--validate-config", is_flag=True, default=False, help="Validate configuration before executing migrations"
+    )
     @click.pass_context
-    def sqlspec_group(ctx: "click.Context", config: str) -> None:
+    def sqlspec_group(ctx: "click.Context", config: str, validate_config: bool) -> None:
         """SQLSpec CLI commands."""
         from rich import get_console
 
-        from sqlspec.utils import module_loader
+        from sqlspec.exceptions import ConfigResolverError
+        from sqlspec.utils.config_resolver import resolve_config_sync
 
         console = get_console()
         ctx.ensure_object(dict)
+
+        # Add current working directory to sys.path to allow loading local config modules
+        cwd = str(Path.cwd())
+        cwd_added = False
+        if cwd not in sys.path:
+            sys.path.insert(0, cwd)
+            cwd_added = True
+
         try:
-            config_instance = module_loader.import_string(config)
-            if isinstance(config_instance, Sequence):
-                ctx.obj["configs"] = config_instance
+            config_result = resolve_config_sync(config)
+            if isinstance(config_result, Sequence) and not isinstance(config_result, str):
+                ctx.obj["configs"] = list(config_result)
             else:
-                ctx.obj["configs"] = [config_instance]
-        except ImportError as e:
+                ctx.obj["configs"] = [config_result]
+
+            ctx.obj["validate_config"] = validate_config
+
+            if validate_config:
+                console.print(f"[green]✓[/] Successfully loaded {len(ctx.obj['configs'])} config(s)")
+                for i, cfg in enumerate(ctx.obj["configs"]):
+                    config_name = cfg.bind_key or f"config-{i}"
+                    config_type = type(cfg).__name__
+                    is_async = cfg.is_async
+                    execution_hint = "[dim cyan](async-capable)[/]" if is_async else "[dim](sync)[/]"
+                    console.print(f"  [dim]•[/] {config_name}: {config_type} {execution_hint}")
+
+        except (ImportError, ConfigResolverError) as e:
             console.print(f"[red]Error loading config: {e}[/]")
             ctx.exit(1)
+        finally:
+            # Clean up: remove the cwd from sys.path if we added it
+            if cwd_added and cwd in sys.path and sys.path[0] == cwd:
+                sys.path.remove(cwd)
 
     return sqlspec_group
 
@@ -109,6 +139,12 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
     dry_run_option = click.option(
         "--dry-run", is_flag=True, default=False, help="Show what would be executed without making changes"
     )
+    execution_mode_option = click.option(
+        "--execution-mode",
+        type=click.Choice(["auto", "sync", "async"]),
+        default="auto",
+        help="Force execution mode (auto-detects by default)",
+    )
 
     def get_config_by_bind_key(
         ctx: "click.Context", bind_key: Optional[str]
@@ -128,7 +164,7 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         else:
             config = None
             for cfg in configs:
-                config_name = getattr(cfg, "name", None) or getattr(cfg, "bind_key", None)
+                config_name = cfg.bind_key
                 if config_name == bind_key:
                     config = cfg
                     break
@@ -164,15 +200,11 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
             # 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)
+            migration_config = actual_config.migration_config
             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__)
-                    )
+                    config_name = actual_config.bind_key or str(type(actual_config).__name__)
                     migration_configs.append((config_name, actual_config))
 
         return migration_configs
@@ -197,6 +229,12 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
             filtered = [(name, config) for name, config in filtered if name not in exclude]
         return filtered
 
+    async def maybe_await(result: Any) -> Any:
+        """Await result if it's a coroutine, otherwise return it directly."""
+        if inspect.iscoroutine(result):
+            return await result
+        return result
+
     def process_multiple_configs(
         ctx: "click.Context",
         bind_key: Optional[str],
@@ -255,34 +293,42 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         bind_key: Optional[str], verbose: bool, include: "tuple[str, ...]", exclude: "tuple[str, ...]"
     ) -> None:
         """Show current database revision."""
-        from sqlspec.migrations.commands import MigrationCommands
+        from sqlspec.migrations.commands import create_migration_commands
+        from sqlspec.utils.sync_tools import run_
 
         ctx = click.get_current_context()
 
-        # 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"
-        )
+        async def _show_current_revision() -> None:
+            # Check if this is a multi-config operation
+            configs_to_process = process_multiple_configs(
+                cast("click.Context", 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
 
-        if configs_to_process is not None:
-            if not configs_to_process:
-                return
+                console.rule("[yellow]Listing current revisions for all configurations[/]", align="left")
 
-            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 = create_migration_commands(config=config)
+                        await maybe_await(migration_commands.current(verbose=verbose))
+                    except Exception as e:
+                        console.print(f"[red]✗ Failed to get current revision for {config_name}: {e}[/]")
+            else:
+                console.rule("[yellow]Listing current revision[/]", align="left")
+                sqlspec_config = get_config_by_bind_key(cast("click.Context", ctx), bind_key)
+                migration_commands = create_migration_commands(config=sqlspec_config)
+                await maybe_await(migration_commands.current(verbose=verbose))
 
-            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)
+        run_(_show_current_revision)()
 
     @database_group.command(name="downgrade", help="Downgrade database to a specific revision.")
     @bind_key_option
@@ -302,47 +348,56 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         """Downgrade the database to the latest revision."""
         from rich.prompt import Confirm
 
-        from sqlspec.migrations.commands import MigrationCommands
+        from sqlspec.migrations.commands import create_migration_commands
+        from sqlspec.utils.sync_tools import run_
 
         ctx = click.get_current_context()
 
-        # 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 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?")
+        async def _downgrade_database() -> None:
+            # Check if this is a multi-config operation
+            configs_to_process = process_multiple_configs(
+                cast("click.Context", 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 = create_migration_commands(config=config)
+                        await maybe_await(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(cast("click.Context", ctx), bind_key)
+                    migration_commands = create_migration_commands(config=sqlspec_config)
+                    await maybe_await(migration_commands.downgrade(revision=revision))
+
+        run_(_downgrade_database)()
 
     @database_group.command(name="upgrade", help="Upgrade database to a specific revision.")
     @bind_key_option
@@ -350,6 +405,7 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
     @include_option
     @exclude_option
     @dry_run_option
+    @execution_mode_option
     @click.argument("revision", type=str, default="head")
     def upgrade_database(  # pyright: ignore[reportUnusedFunction]
         bind_key: Optional[str],
@@ -358,63 +414,79 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         include: "tuple[str, ...]",
         exclude: "tuple[str, ...]",
         dry_run: bool,
+        execution_mode: str,
     ) -> None:
         """Upgrade the database to the latest revision."""
         from rich.prompt import Confirm
 
-        from sqlspec.migrations.commands import MigrationCommands
+        from sqlspec.migrations.commands import create_migration_commands
+        from sqlspec.utils.sync_tools import run_
 
         ctx = click.get_current_context()
 
-        # 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 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?[/]")
+        async def _upgrade_database() -> None:
+            # Report execution mode when specified
+            if execution_mode != "auto":
+                console.print(f"[dim]Execution mode: {execution_mode}[/]")
+
+            # Check if this is a multi-config operation
+            configs_to_process = process_multiple_configs(
+                cast("click.Context", 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 = create_migration_commands(config=config)
+                        await maybe_await(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(cast("click.Context", ctx), bind_key)
+                    migration_commands = create_migration_commands(config=sqlspec_config)
+                    await maybe_await(migration_commands.upgrade(revision=revision))
+
+        run_(_upgrade_database)()
 
     @database_group.command(help="Stamp the revision table with the given revision")
     @click.argument("revision", type=str)
     @bind_key_option
     def stamp(bind_key: Optional[str], revision: str) -> None:  # pyright: ignore[reportUnusedFunction]
         """Stamp the revision table with the given revision."""
-        from sqlspec.migrations.commands import MigrationCommands
+        from sqlspec.migrations.commands import create_migration_commands
+        from sqlspec.utils.sync_tools import run_
 
         ctx = click.get_current_context()
-        sqlspec_config = get_config_by_bind_key(ctx, bind_key)
-        migration_commands = MigrationCommands(config=sqlspec_config)
-        migration_commands.stamp(revision=revision)
+
+        async def _stamp() -> None:
+            sqlspec_config = get_config_by_bind_key(cast("click.Context", ctx), bind_key)
+            migration_commands = create_migration_commands(config=sqlspec_config)
+            await maybe_await(migration_commands.stamp(revision=revision))
+
+        run_(_stamp)()
 
     @database_group.command(name="init", help="Initialize migrations for the project.")
     @bind_key_option
@@ -427,24 +499,37 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         """Initialize the database migrations."""
         from rich.prompt import Confirm
 
-        from sqlspec.migrations.commands import MigrationCommands
+        from sqlspec.extensions.litestar.config import DatabaseConfig
+        from sqlspec.migrations.commands import create_migration_commands
+        from sqlspec.utils.sync_tools import run_
 
         ctx = click.get_current_context()
-        console.rule("[yellow]Initializing database migrations.", align="left")
-        input_confirmed = (
-            True if no_prompt else Confirm.ask("[bold]Are you sure you want initialize migrations for the project?[/]")
-        )
-        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:
-                # 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=actual_config)
-                migration_commands.init(directory=cast("str", directory), package=package)
+
+        async def _init_sqlspec() -> None:
+            console.rule("[yellow]Initializing database migrations.", align="left")
+            input_confirmed = (
+                True
+                if no_prompt
+                else Confirm.ask("[bold]Are you sure you want initialize migrations for the project?[/]")
+            )
+            if input_confirmed:
+                configs = (
+                    [get_config_by_bind_key(cast("click.Context", ctx), bind_key)]
+                    if bind_key is not None
+                    else cast("click.Context", ctx).obj["configs"]
+                )
+
+                for config in configs:
+                    # 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", {})
+                    target_directory = (
+                        migration_config.get("script_location", "migrations") if directory is None else directory
+                    )
+                    migration_commands = create_migration_commands(config=actual_config)
+                    await maybe_await(migration_commands.init(directory=cast("str", target_directory), package=package))
+
+        run_(_init_sqlspec)()
 
     @database_group.command(name="make-migrations", help="Create a new migration revision.")
     @bind_key_option
@@ -456,24 +541,45 @@ def add_migration_commands(database_group: Optional["Group"] = None) -> "Group":
         """Create a new database revision."""
         from rich.prompt import Prompt
 
-        from sqlspec.migrations.commands import MigrationCommands
+        from sqlspec.migrations.commands import create_migration_commands
+        from sqlspec.utils.sync_tools import run_
 
         ctx = click.get_current_context()
-        console.rule("[yellow]Creating new migration revision[/]", align="left")
-        if message is None:
-            message = "new migration" if no_prompt else Prompt.ask("Please enter a message describing this revision")
 
-        sqlspec_config = get_config_by_bind_key(ctx, bind_key)
-        migration_commands = MigrationCommands(config=sqlspec_config)
-        migration_commands.revision(message=message)
+        async def _create_revision() -> None:
+            console.rule("[yellow]Creating new migration revision[/]", align="left")
+            message_text = message
+            if message_text is None:
+                message_text = (
+                    "new migration" if no_prompt else Prompt.ask("Please enter a message describing this revision")
+                )
+
+            sqlspec_config = get_config_by_bind_key(cast("click.Context", ctx), bind_key)
+            migration_commands = create_migration_commands(config=sqlspec_config)
+            await maybe_await(migration_commands.revision(message=message_text))
+
+        run_(_create_revision)()
 
     @database_group.command(name="show-config", help="Show all configurations with migrations enabled.")
-    def show_config() -> None:  # pyright: ignore[reportUnusedFunction]
+    @bind_key_option
+    def show_config(bind_key: Optional[str] = None) -> 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 bind_key is provided, filter to only that config
+        if bind_key is not None:
+            get_config_by_bind_key(cast("click.Context", ctx), bind_key)
+            # Convert single config to list format for compatibility
+            all_configs = cast("click.Context", ctx).obj["configs"]
+            migration_configs = []
+            for cfg in all_configs:
+                config_name = cfg.bind_key
+                if config_name == bind_key and hasattr(cfg, "migration_config") and cfg.migration_config:
+                    migration_configs.append((config_name, cfg))
+        else:
+            migration_configs = get_configs_with_migrations(cast("click.Context", ctx))
 
         if not migration_configs:
             console.print("[yellow]No configurations with migrations detected.[/]")