fast-feature-storage-sqlalchemy 0.0.1__py3-none-any.whl

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/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/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/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/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/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)

fast_feature_storage_sqlalchemy-0.0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+fast_feature/storage/sqlalchemy/__init__.py,sha256=_v1JLDRqd-5OSAszO2R1JPImiv7ez0Xl64MRTxv9wJc,313
+fast_feature/storage/sqlalchemy/base.py,sha256=fBAuFeR2wxQhq-oxbcpyfpFhm2Oco2AKW32wfbcd_nI,175
+fast_feature/storage/sqlalchemy/mapper.py,sha256=QwGU6IkazMXRDEUoFF-F0ZIbzex2Knj-JSfnn512tGE,1381
+fast_feature/storage/sqlalchemy/model.py,sha256=RUIXzxRKA85t-W2AN_qXXh3arnkedeZxPlAo2PKDkks,982
+fast_feature/storage/sqlalchemy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fast_feature/storage/sqlalchemy/repository.py,sha256=H1TI5T3h-jb0eYqqWGdH_nax1K3sdctjfhSjKS5-SxY,2132
+fast_feature/storage/sqlalchemy/schema.py,sha256=dgw5yhW8qJCWqDxEuOtS92oWRetlbqk7HIUQHvw65UU,500
+fast_feature_storage_sqlalchemy-0.0.1.dist-info/WHEEL,sha256=8ZlpUMJ7mlDirmlHRhDirEx_nPnARrwDjeE92mlk68E,81
+fast_feature_storage_sqlalchemy-0.0.1.dist-info/METADATA,sha256=GLQ2R-LVrFENckGKl27Uh0GgQxT9yqPRKYqqnHIBIaY,787
+fast_feature_storage_sqlalchemy-0.0.1.dist-info/RECORD,,

fast_feature_storage_sqlalchemy-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.21
+Root-Is-Purelib: true
+Tag: py3-none-any