fast-feature-storage-sqlalchemy 0.0.1__tar.gz

fast_feature_storage_sqlalchemy-0.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: fast-feature-storage-sqlalchemy
+Version: 0.0.1
+Summary: Async SQLAlchemy storage backend for fast-feature (shared by the SQL drivers).
+Author: byunjuneseok
+Author-email: byunjuneseok <byunjuneseok@gmail.com>
+License-Expression: Apache-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Dist: fast-feature-core==0.0.1
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Python: >=3.10

fast_feature_storage_sqlalchemy-0.0.1/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "fast-feature-storage-sqlalchemy"
+version = "0.0.1"
+description = "Async SQLAlchemy storage backend for fast-feature (shared by the SQL drivers)."
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "byunjuneseok", email = "byunjuneseok@gmail.com" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "fast-feature-core==0.0.1",
+    "sqlalchemy[asyncio]>=2.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.17,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "fast_feature.storage.sqlalchemy"
+
+[tool.uv.sources]
+fast-feature-core = { workspace = true }

fast_feature_storage_sqlalchemy-0.0.1/src/fast_feature/storage/sqlalchemy/__init__.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from .base import Base
+from .mapper import FlagMapper
+from .model import FeatureFlagRow
+from .repository import SqlAlchemyFlagRepository
+from .schema import Schema
+
+__all__ = [
+    "Base",
+    "FeatureFlagRow",
+    "FlagMapper",
+    "SqlAlchemyFlagRepository",
+    "Schema",
+]

fast_feature_storage_sqlalchemy-0.0.1/src/fast_feature/storage/sqlalchemy/base.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    """Declarative base for fast-feature's SQLAlchemy models."""

fast_feature_storage_sqlalchemy-0.0.1/src/fast_feature/storage/sqlalchemy/mapper.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from fast_feature.core import Flag, FlagState
+
+from .model import FeatureFlagRow
+
+
+class FlagMapper:
+    """Translates between the domain ``Flag`` and the ORM row."""
+
+    @staticmethod
+    def to_row(flag: Flag) -> FeatureFlagRow:
+        return FeatureFlagRow(
+            key=flag.key,
+            variants=flag.variants,
+            default_variant=flag.default_variant,
+            state=flag.state.value,
+            targeting=flag.targeting,
+            flag_metadata=flag.metadata,
+            created_at=flag.created_at,
+            updated_at=flag.updated_at,
+        )
+
+    @staticmethod
+    def to_domain(row: FeatureFlagRow) -> Flag:
+        return Flag(
+            key=row.key,
+            variants=row.variants,
+            default_variant=row.default_variant,
+            state=FlagState(row.state),
+            targeting=row.targeting,
+            metadata=row.flag_metadata,
+            created_at=row.created_at,
+            updated_at=row.updated_at,
+        )
+
+    @staticmethod
+    def apply(row: FeatureFlagRow, flag: Flag) -> None:
+        row.variants = flag.variants
+        row.default_variant = flag.default_variant
+        row.state = flag.state.value
+        row.targeting = flag.targeting
+        row.flag_metadata = flag.metadata
+        row.created_at = flag.created_at
+        row.updated_at = flag.updated_at

fast_feature_storage_sqlalchemy-0.0.1/src/fast_feature/storage/sqlalchemy/model.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy import JSON, DateTime, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base
+
+
+class FeatureFlagRow(Base):
+    __tablename__ = "feature_flags"
+
+    key: Mapped[str] = mapped_column(String(255), primary_key=True)
+    variants: Mapped[dict[str, Any]] = mapped_column(JSON, nullable=False)
+    default_variant: Mapped[str] = mapped_column(String(255), nullable=False)
+    state: Mapped[str] = mapped_column(String(32), nullable=False)
+    targeting: Mapped[dict[str, Any] | None] = mapped_column(JSON, nullable=True)
+    # "metadata" is reserved on declarative classes, so the attribute is renamed.
+    flag_metadata: Mapped[dict[str, Any]] = mapped_column("metadata", JSON, nullable=False)
+    created_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)

fast_feature_storage_sqlalchemy-0.0.1/src/fast_feature/storage/sqlalchemy/repository.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from fast_feature.core import Flag, FlagAlreadyExistsError, FlagNotFoundError, FlagRepository
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from .mapper import FlagMapper
+from .model import FeatureFlagRow
+
+
+class SqlAlchemyFlagRepository(FlagRepository):
+    """A ``FlagRepository`` backed by an async SQLAlchemy session factory."""
+
+    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
+        self._session_factory = session_factory
+
+    async def get(self, key: str) -> Flag | None:
+        async with self._session_factory() as session:
+            row = await session.get(FeatureFlagRow, key)
+            return FlagMapper.to_domain(row) if row is not None else None
+
+    async def list_all(self) -> list[Flag]:
+        async with self._session_factory() as session:
+            result = await session.execute(select(FeatureFlagRow).order_by(FeatureFlagRow.key))
+            return [FlagMapper.to_domain(row) for row in result.scalars()]
+
+    async def create(self, flag: Flag) -> Flag:
+        async with self._session_factory() as session:
+            session.add(FlagMapper.to_row(flag))
+            try:
+                await session.commit()
+            except IntegrityError as exc:
+                await session.rollback()
+                raise FlagAlreadyExistsError(flag.key) from exc
+            return flag
+
+    async def update(self, flag: Flag) -> Flag:
+        async with self._session_factory() as session:
+            row = await session.get(FeatureFlagRow, flag.key)
+            if row is None:
+                raise FlagNotFoundError(flag.key)
+            FlagMapper.apply(row, flag)
+            await session.commit()
+            return flag
+
+    async def delete(self, key: str) -> None:
+        async with self._session_factory() as session:
+            row = await session.get(FeatureFlagRow, key)
+            if row is None:
+                raise FlagNotFoundError(key)
+            await session.delete(row)
+            await session.commit()

fast_feature_storage_sqlalchemy-0.0.1/src/fast_feature/storage/sqlalchemy/schema.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+from .base import Base
+
+
+class Schema:
+    """Creates the database schema.
+
+    Convenient for development and tests; production deployments should manage
+    the ``feature_flags`` table with their own migration tooling.
+    """
+
+    @staticmethod
+    async def create_all(engine: AsyncEngine) -> None:
+        async with engine.begin() as connection:
+            await connection.run_sync(Base.metadata.create_all)