sqliac 0.1.0__tar.gz

sqliac-0.1.0/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 ruskgo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

sqliac-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: sqliac
+Version: 0.1.0
+Summary: An alternative to Terraform for SQL databases without using a state.
+Author-email: Ruslan Gonzalez Konstantinov <rus.kgo.gmail@example.com>
+License: MIT License
+        
+        Copyright (c) 2026 ruskgo
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+        associated documentation files (the "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+        following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial
+        portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+        LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+        EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+        IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+        USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://codeberg.org/ruskgo/sqliac
+Project-URL: Bug Tracker, https://codeberg.org/ruskgo/sqliac/issues
+Keywords: sql,iac,terraform-alternative,database
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Jinja2
+Requires-Dist: rich
+Requires-Dist: sqlparse
+Requires-Dist: dictdiffer
+Provides-Extra: dev
+Requires-Dist: pytest>=9.1.1; extra == "dev"
+Provides-Extra: snowflake
+Requires-Dist: sqliac-snowflake; extra == "snowflake"
+Dynamic: license-file

sqliac-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "sqliac"
+version = "0.1.0"
+description = "An alternative to Terraform for SQL databases without using a state."
+readme = "README.md"
+requires-python = ">=3.12"
+license = { file = "LICENSE" }
+authors = [
+  { name = "Ruslan Gonzalez Konstantinov", email = "rus.kgo.gmail@example.com" },
+]
+keywords = ["sql", "iac", "terraform-alternative", "database"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Developers",
+  "Topic :: Database",
+]
+dependencies = ["Jinja2", "rich", "sqlparse", "dictdiffer"]
+[project.urls]
+Homepage = "https://codeberg.org/ruskgo/sqliac"
+"Bug Tracker" = "https://codeberg.org/ruskgo/sqliac/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=9.1.1"]
+snowflake = ["sqliac-snowflake"]
+
+[tool.uv.workspace]
+members = ["sqliac_adapters/sqliac_snowflake"]
+
+[tool.uv.sources]
+sqliac-snowflake = { workspace = true }
+
+[project.scripts]
+sqliac = "sqliac.cli:main"
+
+[tool.setuptools.package-data]
+sqliac = ["templates/**/*.toml", "templates/**/*.sql"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"

sqliac-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqliac-0.1.0/src/sqliac/__init__.py

@@ -0,0 +1,20 @@
+"""sqliac - SQL Infrastructure as Code."""
+
+__version__ = "0.1.0"
+__author__ = "Ruslan Gonzalez Konstantinov"
+__license__ = "MIT"
+__prog_name__ = "sqliac"
+
+from sqliac.constants import TemplateType, DDLCommand, IacAction, RunMode, Paths
+
+__all__ = [
+    # Version
+    "__version__",
+    "__author__",
+    "__license__",
+    "TemplateType",
+    "DDLCommand",
+    "IacAction",
+    "RunMode",
+    "Paths",
+]

sqliac-0.1.0/src/sqliac/__main__.py

@@ -0,0 +1,6 @@
+"""SQLIaC entry point."""
+
+from sqliac import cli
+
+if __name__ == "__main__":
+    cli.main()

sqliac-0.1.0/src/sqliac/adapters/__init__.py

@@ -0,0 +1,17 @@
+"""Adapters package for sqliac."""
+
+__version__ = "0.1.0"
+
+from .base import (
+    BaseAdapter,
+    BaseCredentials,
+)
+from .factory import AdapterFactory
+
+__all__ = [
+    # Base classes
+    "BaseAdapter",
+    "BaseCredentials",
+    # Factory
+    "AdapterFactory",
+]

sqliac-0.1.0/src/sqliac/adapters/base.py

@@ -0,0 +1,154 @@
+"""Simplified, production-grade SQL adapter layer."""
+
+from __future__ import annotations
+
+import abc
+import os
+import tomllib
+from pathlib import Path
+from tomllib import TOMLDecodeError
+from typing import Any, Type
+
+import sqlparse
+
+from sqliac import Paths
+from sqliac.adapters.connection_manager import ThreadConnectionManager
+from sqliac.errors import RustyError
+from sqliac.template_engine import TemplateEngine
+
+
+class BaseCredentials(abc.ABC):
+    """Abstract base class establishing database connection credentials."""
+
+    @property
+    @abc.abstractmethod
+    def dialect(self) -> str:
+        """The identifier string for the target database system."""
+        raise NotImplementedError(
+            f"Credentials class {self.__class__.__name__} must implement 'dialect' property."
+        )
+
+    def __post_init__(self):
+        """Validate if the required fields are present."""
+        raise NotImplementedError(
+            f"Credentials class {self.__class__.__name__} must implement post init validation."
+        )
+
+
+class BaseAdapter(abc.ABC):
+    """Abstract base class handling configuration lifecycles and query execution."""
+
+    # Define the concrete Connection Manager class
+    ConnectionManager: Type[ThreadConnectionManager]
+
+    # Standard Types
+    Row = tuple[Any, ...] | None
+
+    def __init__(self) -> None:
+        # Load environment credentials immediately upon initialization
+        self.credentials = self._load_credentials()
+        self.connections = self.ConnectionManager(self.credentials)
+
+    @property
+    @abc.abstractmethod
+    def dialect(self) -> str:
+        """The identifier string for the target database system."""
+        pass
+
+    @property
+    @abc.abstractmethod
+    def credentials_class(self) -> type[BaseCredentials]:
+        """The concrete Credentials class associated with this adapter."""
+        raise NotImplementedError(
+            f"Adapter class {self.__class__.__name__} must implement 'credentials_class' property."
+        )
+
+    @abc.abstractmethod
+    def _fetch_row(self, cursor: Any) -> Row:
+        """Process an open database cursor into standard formatted row."""
+        raise NotImplementedError(
+            f"Adapter class {self.__class__.__name__} must implement '_fetch_row' method."
+        )
+
+    def _load_credentials(self) -> BaseCredentials:
+        """Load from file or environment variables prefixed with the dialect name."""
+        target_path = self._resolve_path(Paths.PROVIDER_CREDENTIALS_FILE)
+        if target_path.is_file():
+            try:
+                with open(target_path, "rb") as f:
+                    config = tomllib.load(f)
+
+                if self.dialect in config:
+                    for key, value in config[self.dialect].items():
+                        os.environ[f"{self.dialect.upper()}_{key.upper()}"] = str(value)
+
+            except TOMLDecodeError as err:
+                raise RustyError(
+                    error="invalid TOML file",
+                    file=str(target_path),
+                    help="check TOML formatting in the definition file",
+                ) from err
+
+            except PermissionError:
+                raise RustyError(
+                    error="read permission denied",
+                    file=str(target_path),
+                    help="the file might be open by another application or missing read permissions",
+                ) from None
+
+        prefix = f"{self.dialect.upper()}_"
+        credentials = {
+            key.replace(prefix, "").lower(): val
+            for key, val in os.environ.items()
+            if key.startswith(prefix)
+        }
+
+        return self.credentials_class(**credentials)
+
+    @staticmethod
+    def _resolve_path(path: Path):
+        return path if path.is_absolute() else Path.cwd() / path
+
+    def _split_statements(self, sql: str) -> list[str]:
+        """Cleans syntax comments and splits batches into single statements."""
+        formatted = TemplateEngine.pretty_sql(sql)
+        return [str(s).strip() for s in sqlparse.parse(formatted) if str(s).strip()]
+
+    def execute(self, sql: str) -> Row:
+        """Executes one or more SQL statements sequentially within a clean connection lifecycle."""
+        statements = self._split_statements(sql)
+
+        with self.connections.get_connection() as conn:
+            try:
+                cursor = conn.cursor()
+            except Exception as err:
+                raise RustyError(
+                    error="failed to get the connection cursor", details=str(err)
+                )
+
+            for statement in statements:
+                try:
+                    if cursor:
+                        cursor.execute(statement)
+                except RustyError:
+                    raise
+                except Exception as err:
+                    raise RustyError(
+                        error="SQL statement execution error",
+                        sql=TemplateEngine.pretty_sql(sql=statement),
+                        details=str(err),
+                    ) from err
+
+            return self._fetch_row(cursor)
+
+    def cleanup(self) -> None:
+        """Cleans up all managed connections."""
+        self.connections.cleanup_all()
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - cleanup connections."""
+        self.cleanup()

sqliac-0.1.0/src/sqliac/adapters/connection_manager.py

@@ -0,0 +1,135 @@
+"""Manages database connections with thread safety and connection pooling."""
+
+import abc
+import threading
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, ClassVar, Generator
+
+
+@dataclass
+class ConnectionState:
+    """Represents the current state of a database connection.
+
+    Args:
+        name(str): Unique identifier for this connection thread
+        state(str): Current state ('init', 'open', 'closed', 'fail')
+        handle(str): The underlying database connection object
+        credentials(str): Credentials used to establish this connection
+    """
+
+    name: str
+    state: str = "init"
+    handle: Any | None = None
+    credentials: Any | None = None
+
+
+class ThreadConnectionManager(abc.ABC):
+    """Manages database connections with thread safety."""
+
+    # Each adapter implementation must define its type of credentials
+    CredentialsClass: ClassVar[type[Any]]
+
+    def __init__(self, credentials: Any):
+        """Initialize the connection manager.
+
+        Args:
+            credentials: Database credentials for establishing connections
+        """
+        self.credentials = credentials
+
+        # Dictionary to store one connection per thread
+        # Key: thread name, Value: ConnectionState object
+        self.thread_connections: dict[str, ConnectionState] = {}
+
+        # Reentrant lock allows the same thread to acquire it multiple times
+        self.lock = threading.RLock()
+
+    def get_thread_identifier(self) -> str:
+        """Get unique identifier for the current thread."""
+        return threading.current_thread().name
+
+    def get_thread_connection(self) -> ConnectionState:
+        """Get or create connection for the current thread."""
+        thread_id = self.get_thread_identifier()
+
+        # Thread-safe access to the connections dictionary
+        with self.lock:
+            if thread_id not in self.thread_connections:
+                # Create a new connection state for this thread
+                self.thread_connections[thread_id] = ConnectionState(
+                    name=thread_id,
+                    credentials=self.credentials,
+                )
+
+        return self.thread_connections[thread_id]
+
+    @abc.abstractmethod
+    def open(self, connection: ConnectionState) -> ConnectionState:
+        """Open a new database connection.
+
+        This method must be implemented by each database adapter to handle
+        the specific connection logic for that database.
+
+        Args:
+            connection: ConnectionState object to populate with connection
+
+        Returns:
+            Updated ConnectionState with opened connection
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must implement the 'open' method"
+        )
+
+    def close(self, conn_state: ConnectionState) -> ConnectionState:
+        """Close a database connection."""
+        if conn_state.state == "closed":
+            return conn_state
+
+        if conn_state.handle is not None:
+            try:
+                # Handle custom connection types
+                conn_state.handle.close()
+            except Exception as e:
+                # Log warning instead of raising, as we are cleaning up
+                print(f"warning: error closing connection {conn_state.name}: {e}")
+                pass
+
+        # Update state
+        conn_state.state = "closed"
+        conn_state.handle = None
+
+        return conn_state
+
+    def cleanup_all(self) -> None:
+        """Close all open connections across all threads."""
+        with self.lock:
+            for connection in self.thread_connections.values():
+                if connection.state == "open":
+                    self.close(connection)
+            # Clear the connections dictionary
+            self.thread_connections.clear()
+
+    @contextmanager
+    def get_connection(self) -> Generator[Any]:
+        """Context manager to get and manage a database connection.
+
+        Yields:
+            SQL server connection object ready for use
+        """
+        # Get or create connection state for this thread
+        conn_state = self.get_thread_connection()
+
+        # Open connection if not already open
+        if conn_state.state != "open":
+            self.close(conn_state)
+            # Ensure the concrete open method is called
+            conn_state = self.open(conn_state)
+
+        try:
+            # Yield the actual database connection handle
+            yield conn_state.handle  # pyright: ignore[reportReturnType]
+        except Exception:
+            # Mark connection as failed on exception
+            conn_state.state = "fail"
+            raise

sqliac-0.1.0/src/sqliac/adapters/factory.py

@@ -0,0 +1,30 @@
+"""Adapter factory for creating database adapters."""
+
+from __future__ import annotations
+
+from importlib.metadata import entry_points
+
+from sqliac.errors import RustyError
+
+
+class AdapterFactory:
+    GROUP = "sqliac.adapters"
+
+    @classmethod
+    def list_adapters(cls) -> list[str]:
+        return sorted(ep.name for ep in entry_points(group=cls.GROUP))
+
+    @classmethod
+    def get_adapter(cls, provider: str):
+        adapters = {ep.name: ep for ep in entry_points(group=cls.GROUP)}
+        try:
+            adapter_cls = adapters[provider]
+        except KeyError:
+            available = ", ".join(sorted(adapters)) or "none installed"
+            raise RustyError(
+                error=f"adapter `{provider}` is not installed",
+                help=f"install it, e.g. `pip install sqliac-{provider}`",
+                details=f"available adapters: {available}",
+            )
+
+        return adapter_cls.load()()