sqlspec 0.46.2__tar.gz → 0.46.3__tar.gz

{sqlspec-0.46.2 → sqlspec-0.46.3}/PKG-INFO

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

{sqlspec-0.46.2 → sqlspec-0.46.3}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.46.2"
+version = "0.46.3"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -264,7 +264,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.46.2"
+current_version = "0.46.3"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.46.2 → sqlspec-0.46.3}/sqlspec/exceptions.py

@@ -35,6 +35,7 @@ __all__ = (
     "SQLFileParseError",
     "SQLParsingError",
     "SQLSpecError",
+    "SQLStatementNotFoundError",
     "SerializationConflictError",
     "SerializationError",
     "SquashValidationError",
@@ -323,6 +324,31 @@ class SQLFileNotFoundError(SQLSpecError):
         self.path = path
 
 
+class SQLStatementNotFoundError(SQLFileNotFoundError):
+    """Raised when a named SQL statement is not loaded."""
+
+    def __init__(self, name: str, normalized_name: str, query_count: int) -> None:
+        """Initialize the error.
+
+        Args:
+            name: Name requested by the caller.
+            normalized_name: Normalized statement name used for lookup.
+            query_count: Number of SQL statements loaded in the registry.
+        """
+        if query_count == 0:
+            message = f"SQL statement '{name}' not found. No SQL statements are loaded."
+        else:
+            message = (
+                f"SQL statement '{name}' not found. {query_count} SQL statements are loaded. "
+                "Use list_queries() to inspect available statement names."
+            )
+        SQLSpecError.__init__(self, message)
+        self.name = name
+        self.path = None
+        self.normalized_name = normalized_name
+        self.query_count = query_count
+
+
 class SQLFileParseError(SQLSpecError):
     """Raised when a SQL file cannot be parsed."""
 

{sqlspec-0.46.2 → sqlspec-0.46.3}/sqlspec/extensions/litestar/plugin.py

@@ -481,10 +481,8 @@ class SQLSpecPlugin(InitPluginProtocol, CLIPlugin):
         if signature_namespace:
             app_config.signature_namespace.update(signature_namespace)
 
-        existing_plugins = list(app_config.plugins or [])
-        if not any(isinstance(p, _OffsetPaginationSchemaPlugin) for p in existing_plugins):
-            existing_plugins.append(_OffsetPaginationSchemaPlugin())
-        app_config.plugins = existing_plugins
+        if not any(isinstance(p, _OffsetPaginationSchemaPlugin) for p in app_config.plugins):
+            app_config.plugins.append(_OffsetPaginationSchemaPlugin())
 
         if app_config.exception_handlers is None:
             app_config.exception_handlers = {}

{sqlspec-0.46.2 → sqlspec-0.46.3}/sqlspec/loader.py

@@ -21,6 +21,7 @@ from sqlspec.exceptions import (
     FileNotFoundInStorageError,
     SQLFileNotFoundError,
     SQLFileParseError,
+    SQLStatementNotFoundError,
     StorageOperationFailedError,
 )
 from sqlspec.storage.registry import storage_registry as default_storage_registry
@@ -206,6 +207,18 @@ class SQLFileLoader:
         """
         raise SQLFileNotFoundError(path)
 
+    def _raise_statement_not_found(self, name: str, normalized_name: str) -> None:
+        """Raise SQLStatementNotFoundError for nonexistent statements.
+
+        Args:
+            name: Name requested by the caller.
+            normalized_name: Normalized statement name used for lookup.
+
+        Raises:
+            SQLStatementNotFoundError: Always raised.
+        """
+        raise SQLStatementNotFoundError(name=name, normalized_name=normalized_name, query_count=len(self._queries))
+
     def _generate_file_cache_key(self, path: str | Path) -> str:
         """Generate cache key for a file path.
 
@@ -676,11 +689,11 @@ class SQLFileLoader:
             Raw SQL text.
 
         Raises:
-            SQLFileNotFoundError: If query not found.
+            SQLStatementNotFoundError: If query not found.
         """
         safe_name = _normalize_query_name(name)
         if safe_name not in self._queries:
-            raise SQLFileNotFoundError(name)
+            self._raise_statement_not_found(name, safe_name)
         return self._queries[safe_name].sql
 
     def get_sql(self, name: str) -> "SQL":
@@ -694,13 +707,12 @@ class SQLFileLoader:
             SQL object ready for execution.
 
         Raises:
-            SQLFileNotFoundError: If statement name not found.
+            SQLStatementNotFoundError: If statement name not found.
         """
         safe_name = _normalize_query_name(name)
 
         if safe_name not in self._queries:
-            available = ", ".join(sorted(self._queries.keys())) if self._queries else "none"
-            raise SQLFileNotFoundError(name, path=f"Statement '{name}' not found. Available statements: {available}")
+            self._raise_statement_not_found(name, safe_name)
 
         parsed_statement = self._queries[safe_name]
         sqlglot_dialect = None

{sqlspec-0.46.2 → sqlspec-0.46.3}/tests/unit/exceptions/test_exceptions.py

@@ -7,7 +7,9 @@ from sqlspec.exceptions import (
     NotFoundError,
     NotNullViolationError,
     OperationalError,
+    SQLFileNotFoundError,
     SQLSpecError,
+    SQLStatementNotFoundError,
     StackExecutionError,
     TransactionError,
     UniqueViolationError,
@@ -25,6 +27,7 @@ def test_new_exception_hierarchy() -> None:
     assert issubclass(TransactionError, SQLSpecError)
     assert issubclass(DataError, SQLSpecError)
     assert issubclass(OperationalError, SQLSpecError)
+    assert issubclass(SQLStatementNotFoundError, SQLFileNotFoundError)
 
 
 def test_exception_instantiation() -> None:
@@ -149,6 +152,21 @@ def test_subclass_inherits_args_behavior() -> None:
     assert str(exc) == "item not found"
 
 
+def test_sql_statement_not_found_exposes_lookup_context() -> None:
+    """Test SQLStatementNotFoundError exposes bounded lookup context."""
+    exc = SQLStatementNotFoundError(name="missing-query", normalized_name="missing_query", query_count=12)
+
+    assert isinstance(exc, SQLFileNotFoundError)
+    assert exc.name == "missing-query"
+    assert exc.path is None
+    assert exc.normalized_name == "missing_query"
+    assert exc.query_count == 12
+    assert str(exc) == (
+        "SQL statement 'missing-query' not found. 12 SQL statements are loaded. "
+        "Use list_queries() to inspect available statement names."
+    )
+
+
 def test_stack_execution_error_preserves_args() -> None:
     """Test StackExecutionError correctly populates args."""
     original = ValueError("boom")

sqlspec-0.46.3/tests/unit/extensions/test_litestar/test_plugin_ordering.py

@@ -0,0 +1,100 @@
+"""Regression tests for SQLSpecPlugin's interaction with downstream plugins.
+
+Litestar walks ``app_config.plugins`` with a generator expression that captures
+the list reference once. Plugins are allowed to register follow-on plugins by
+mutating that list in place (``.append`` / ``.extend``). If any plugin rebinds
+``app_config.plugins`` to a brand-new list, Litestar's iterator continues
+walking the old list and any plugin appended afterwards is silently dropped.
+
+These tests pin SQLSpecPlugin to the in-place mutation contract.
+"""
+
+from __future__ import annotations
+
+import pytest
+from litestar import Litestar
+from litestar.config.app import AppConfig
+from litestar.plugins import InitPluginProtocol
+
+from sqlspec.adapters.aiosqlite.config import AiosqliteConfig
+from sqlspec.base import SQLSpec
+from sqlspec.extensions.litestar.plugin import SQLSpecPlugin
+
+pytestmark = pytest.mark.xdist_group("extensions_litestar")
+
+
+def _build_sqlspec_plugin() -> SQLSpecPlugin:
+    sqlspec = SQLSpec()
+    sqlspec.add_config(AiosqliteConfig(connection_config={"database": ":memory:"}))
+    return SQLSpecPlugin(sqlspec=sqlspec)
+
+
+class _FollowOnPlugin(InitPluginProtocol):
+    """Marker plugin that records when its ``on_app_init`` fires."""
+
+    def __init__(self, fired: list[str], name: str) -> None:
+        self._fired = fired
+        self._name = name
+
+    def on_app_init(self, app_config: AppConfig) -> AppConfig:
+        self._fired.append(self._name)
+        return app_config
+
+
+class _AppendsFollowOnPlugin(InitPluginProtocol):
+    """Plugin that registers a follow-on plugin during its own ``on_app_init``.
+
+    Mirrors the ``litestar-vite`` ``VitePlugin`` -> ``InertiaPlugin`` pattern
+    that originally surfaced this bug.
+    """
+
+    def __init__(self, follow_on: InitPluginProtocol) -> None:
+        self._follow_on = follow_on
+
+    def on_app_init(self, app_config: AppConfig) -> AppConfig:
+        app_config.plugins.append(self._follow_on)
+        return app_config
+
+
+def test_on_app_init_preserves_plugins_list_identity() -> None:
+    """``app_config.plugins`` must be the same list object after ``on_app_init``.
+
+    Rebinding to a new list breaks Litestar's mid-iteration plugin discovery —
+    the iterator captured the old list reference and silently skips anything
+    a later plugin appends to ``app_config.plugins``.
+    """
+    plugin = _build_sqlspec_plugin()
+    app_config = AppConfig()
+    original_plugins = app_config.plugins
+
+    plugin.on_app_init(app_config)
+
+    assert app_config.plugins is original_plugins, (
+        "SQLSpecPlugin.on_app_init rebound app_config.plugins to a new list; "
+        "this breaks downstream plugins that append to it during init."
+    )
+
+
+def test_follow_on_plugin_fires_when_sqlspec_registered_first() -> None:
+    """[SQLSpec, Appender] order: appended follow-on plugin must still init."""
+    fired: list[str] = []
+    follow_on = _FollowOnPlugin(fired, "follow_on")
+    appender = _AppendsFollowOnPlugin(follow_on)
+
+    Litestar(plugins=[_build_sqlspec_plugin(), appender])
+
+    assert "follow_on" in fired, (
+        "Plugin appended to app_config.plugins during init was never called. "
+        "SQLSpecPlugin must mutate app_config.plugins in place, not rebind it."
+    )
+
+
+def test_follow_on_plugin_fires_when_sqlspec_registered_second() -> None:
+    """[Appender, SQLSpec] order: control case — must also fire."""
+    fired: list[str] = []
+    follow_on = _FollowOnPlugin(fired, "follow_on")
+    appender = _AppendsFollowOnPlugin(follow_on)
+
+    Litestar(plugins=[appender, _build_sqlspec_plugin()])
+
+    assert "follow_on" in fired

{sqlspec-0.46.2 → sqlspec-0.46.3}/tests/unit/loader/test_sql_file_loader.py

@@ -10,13 +10,14 @@ Tests for SQLFileLoader core functionality including:
 """
 
 import time
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
 import pytest
 
 from sqlspec.core import SQL
-from sqlspec.exceptions import SQLFileNotFoundError, SQLFileParseError
+from sqlspec.exceptions import SQLFileNotFoundError, SQLFileParseError, SQLStatementNotFoundError
 from sqlspec.loader import (
     NamedStatement,
     SQLFile,
@@ -510,6 +511,44 @@ def test_get_query_text_not_found() -> None:
         loader.get_query_text("nonexistent")
 
 
+@pytest.mark.parametrize("accessor", [SQLFileLoader.get_sql, SQLFileLoader.get_query_text])
+def test_missing_statement_empty_loader_message(accessor: Callable[[SQLFileLoader, str], object]) -> None:
+    """Missing statements in an empty loader should return a bounded message."""
+    loader = SQLFileLoader()
+
+    with pytest.raises(SQLStatementNotFoundError) as exc_info:
+        accessor(loader, "missing-secret")
+
+    exc = exc_info.value
+    assert str(exc) == "SQL statement 'missing-secret' not found. No SQL statements are loaded."
+    assert exc.name == "missing-secret"
+    assert exc.normalized_name == "missing_secret"
+    assert exc.query_count == 0
+
+
+@pytest.mark.parametrize("accessor", [SQLFileLoader.get_sql, SQLFileLoader.get_query_text])
+def test_missing_statement_loaded_registry_message_does_not_leak_names(
+    accessor: Callable[[SQLFileLoader, str], object],
+) -> None:
+    """Missing statements should not dump the loaded statement registry."""
+    loader = SQLFileLoader()
+    loaded_query_names = [f"tenant_{index}_private_query" for index in range(20)]
+    for query_name in loaded_query_names:
+        loader.add_named_sql(query_name, "SELECT 1")
+
+    with pytest.raises(SQLStatementNotFoundError) as exc_info:
+        accessor(loader, "missing-secret")
+
+    message = str(exc_info.value)
+    assert message == (
+        "SQL statement 'missing-secret' not found. 20 SQL statements are loaded. "
+        "Use list_queries() to inspect available statement names."
+    )
+    assert "Available statements" not in message
+    for query_name in loaded_query_names:
+        assert query_name not in message
+
+
 def test_clear_cache() -> None:
     """Test clearing loader cache."""
     loader = SQLFileLoader()
@@ -582,7 +621,7 @@ def test_get_sql_not_found() -> None:
     with pytest.raises(SQLFileNotFoundError) as exc_info:
         loader.get_sql("nonexistent")
 
-    assert "Statement 'nonexistent' not found" in str(exc_info.value)
+    assert "SQL statement 'nonexistent' not found" in str(exc_info.value)
 
 
 def test_get_sql_name_normalization() -> None:

{sqlspec-0.46.2 → sqlspec-0.46.3}/uv.lock

@@ -6922,7 +6922,7 @@ wheels = [
 
 [[package]]
 name = "sqlspec"
-version = "0.46.2"
+version = "0.46.3"
 source = { editable = "." }
 dependencies = [
     { name = "mypy-extensions" },