kodit 0.5.4__py3-none-any.whl → 0.5.5__py3-none-any.whl

kodit/infrastructure/sqlalchemy/git_repository.py

@@ -1,15 +1,15 @@
 """SQLAlchemy implementation of GitRepoRepository."""
 
 from collections.abc import Callable
+from typing import Any, override
 
 from pydantic import AnyUrl
-from sqlalchemy import delete, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.domain.entities.git import GitRepo
+from kodit.domain.entities.git import GitRepo, TrackingConfig, TrackingType
 from kodit.domain.protocols import GitRepoRepository
-from kodit.infrastructure.mappers.git_mapper import GitMapper
 from kodit.infrastructure.sqlalchemy import entities as db_entities
+from kodit.infrastructure.sqlalchemy.repository import SqlAlchemyRepository
 from kodit.infrastructure.sqlalchemy.unit_of_work import SqlAlchemyUnitOfWork
 
 
@@ -20,243 +20,73 @@ def create_git_repo_repository(
     return SqlAlchemyGitRepoRepository(session_factory=session_factory)
 
 
-class SqlAlchemyGitRepoRepository(GitRepoRepository):
-    """SQLAlchemy implementation of GitRepoRepository.
+class SqlAlchemyGitRepoRepository(
+    SqlAlchemyRepository[GitRepo, db_entities.GitRepo], GitRepoRepository
+):
+    """SQLAlchemy implementation of GitRepoRepository."""
 
-    This repository manages the GitRepo aggregate, including:
-    - GitRepo entity
-    - GitBranch entities
-    - GitTag entities
-
-    Note: Commits are now managed by the separate GitCommitRepository.
-    """
-
-    def __init__(self, session_factory: Callable[[], AsyncSession]) -> None:
-        """Initialize the repository."""
-        self.session_factory = session_factory
+    def _get_id(self, entity: GitRepo) -> Any:
+        return entity.id
 
     @property
-    def _mapper(self) -> GitMapper:
-        return GitMapper()
+    def db_entity_type(self) -> type[db_entities.GitRepo]:
+        """The SQLAlchemy model type."""
+        return db_entities.GitRepo
 
-    async def save(self, repo: GitRepo) -> GitRepo:
-        """Save or update a repository with all its branches, commits, and tags."""
+    @override
+    async def save(self, entity: GitRepo) -> GitRepo:
+        """Save entity (create new or update existing)."""
         async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # 1. Save or update the GitRepo entity
-            # Check if repo exists by URI (for new repos from domain)
-            existing_repo_stmt = select(db_entities.GitRepo).where(
-                db_entities.GitRepo.sanitized_remote_uri
-                == str(repo.sanitized_remote_uri)
+            entity_id = self._get_id(entity)
+            # Skip session.get if entity_id is None (new entity not yet persisted)
+            existing_db_entity = (
+                await session.get(self.db_entity_type, entity_id)
+                if entity_id is not None
+                else None
             )
-            existing_repo = await session.scalar(existing_repo_stmt)
 
-            if existing_repo:
-                # Update existing repo found by URI
-                existing_repo.remote_uri = str(repo.remote_uri)
-                existing_repo.cloned_path = repo.cloned_path
-                existing_repo.last_scanned_at = repo.last_scanned_at
-                existing_repo.num_commits = repo.num_commits
-                existing_repo.num_branches = repo.num_branches
-                existing_repo.num_tags = repo.num_tags
-                db_repo = existing_repo
-                repo.id = existing_repo.id  # Set the domain ID
+            if existing_db_entity:
+                # Update existing entity
+                new_db_entity = self.to_db(entity)
+                self._update_db_entity(existing_db_entity, new_db_entity)
+                db_entity = existing_db_entity
             else:
-                # Create new repo
-                db_repo = db_entities.GitRepo(
-                    sanitized_remote_uri=str(repo.sanitized_remote_uri),
-                    remote_uri=str(repo.remote_uri),
-                    cloned_path=repo.cloned_path,
-                    last_scanned_at=repo.last_scanned_at,
-                    num_commits=repo.num_commits,
-                    num_branches=repo.num_branches,
-                    num_tags=repo.num_tags,
-                )
-                session.add(db_repo)
-                await session.flush()  # Get the new ID
-                repo.id = db_repo.id  # Set the domain ID
-
-            # 2. Save tracking branch
-            await self._save_tracking_branch(session, repo)
+                # Create new entity
+                db_entity = self.to_db(entity)
+                session.add(db_entity)
 
             await session.flush()
-            return repo
-
-
-
-    async def _save_tracking_branch(self, session: AsyncSession, repo: GitRepo) -> None:
-        """Save tracking branch if it doesn't exist."""
-        if not repo.tracking_branch:
-            return
-
-        existing_tracking_branch = await session.get(
-            db_entities.GitTrackingBranch, [repo.id, repo.tracking_branch.name]
-        )
-        if not existing_tracking_branch and repo.id is not None:
-            db_tracking_branch = db_entities.GitTrackingBranch(
-                repo_id=repo.id,
-                name=repo.tracking_branch.name,
-            )
-            session.add(db_tracking_branch)
-
-
-    async def get_by_id(self, repo_id: int) -> GitRepo:
-        """Get repository by ID with all associated data."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            db_repo = await session.get(db_entities.GitRepo, repo_id)
-            if not db_repo:
-                raise ValueError(f"Repository with ID {repo_id} not found")
-
-            return await self._load_complete_repo(session, db_repo)
-
-    async def get_by_uri(self, sanitized_uri: AnyUrl) -> GitRepo:
-        """Get repository by sanitized URI with all associated data."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            stmt = select(db_entities.GitRepo).where(
-                db_entities.GitRepo.sanitized_remote_uri == str(sanitized_uri)
-            )
-            db_repo = await session.scalar(stmt)
-            if not db_repo:
-                raise ValueError(f"Repository with URI {sanitized_uri} not found")
-
-            return await self._load_complete_repo(session, db_repo)
-
-    async def get_by_commit(self, commit_sha: str) -> GitRepo:
-        """Get repository by commit SHA with all associated data."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # Find the commit first
-            stmt = select(db_entities.GitCommit).where(
-                db_entities.GitCommit.commit_sha == commit_sha
-            )
-            db_commit = await session.scalar(stmt)
-            if not db_commit:
-                raise ValueError(f"Commit with SHA {commit_sha} not found")
-
-            # Get the repo
-            db_repo = await session.get(db_entities.GitRepo, db_commit.repo_id)
-            if not db_repo:
-                raise ValueError(f"Repository with commit SHA {commit_sha} not found")
-
-            return await self._load_complete_repo(session, db_repo)
-
-    async def get_all(self) -> list[GitRepo]:
-        """Get all repositories."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            stmt = select(db_entities.GitRepo)
-            db_repos = (await session.scalars(stmt)).all()
-
-            repos = []
-            for db_repo in db_repos:
-                repo = await self._load_complete_repo(session, db_repo)
-                repos.append(repo)
-
-            return repos
-
-    async def delete(self, sanitized_uri: AnyUrl) -> bool:
-        """Delete only the repository entity itself.
-
-        According to DDD principles, this repository should only delete
-        the GitRepo entity it directly controls. Related entities (commits,
-        branches, tags, snippets) should be deleted by their respective
-        repositories before calling this method.
-        """
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # Find the repo
-            stmt = select(db_entities.GitRepo).where(
-                db_entities.GitRepo.sanitized_remote_uri == str(sanitized_uri)
-            )
-            db_repo = await session.scalar(stmt)
-            if not db_repo:
-                return False
-
-            # Delete tracking branches first (they reference the repo)
-            del_tracking_branches_stmt = delete(db_entities.GitTrackingBranch).where(
-                db_entities.GitTrackingBranch.repo_id == db_repo.id
-            )
-            await session.execute(del_tracking_branches_stmt)
-
-            # Delete only the repo entity itself
-            # Foreign key constraints will prevent deletion if related entities exist
-            del_stmt = delete(db_entities.GitRepo).where(
-                db_entities.GitRepo.id == db_repo.id
-            )
-            await session.execute(del_stmt)
-            return True
-
-
-    async def _load_complete_repo(
-        self, session: AsyncSession, db_repo: db_entities.GitRepo
-    ) -> GitRepo:
-        """Load a complete repo with all its associations."""
-        all_tags = list(
-            (
-                await session.scalars(
-                    select(db_entities.GitTag).where(
-                        db_entities.GitTag.repo_id == db_repo.id
-                    )
-                )
-            ).all()
+            return self.to_domain(db_entity)
+
+    @staticmethod
+    def to_domain(db_entity: db_entities.GitRepo) -> GitRepo:
+        """Map database entity to domain entity."""
+        return GitRepo(
+            id=db_entity.id,
+            sanitized_remote_uri=AnyUrl(db_entity.sanitized_remote_uri),
+            remote_uri=AnyUrl(db_entity.remote_uri),
+            cloned_path=db_entity.cloned_path,
+            last_scanned_at=db_entity.last_scanned_at,
+            num_commits=db_entity.num_commits,
+            num_branches=db_entity.num_branches,
+            num_tags=db_entity.num_tags,
+            tracking_config=TrackingConfig(
+                type=TrackingType(db_entity.tracking_type),
+                name=db_entity.tracking_name,
+            ),
         )
-        tracking_branch = await session.scalar(
-            select(db_entities.GitTrackingBranch).where(
-                db_entities.GitTrackingBranch.repo_id == db_repo.id
-            )
-        )
-
-        # Get tracking branch from branches table if needed
-        db_tracking_branch_entity = None
-        if tracking_branch:
-            db_tracking_branch_entity = await session.scalar(
-                select(db_entities.GitBranch).where(
-                    db_entities.GitBranch.repo_id == db_repo.id,
-                    db_entities.GitBranch.name == tracking_branch.name,
-                )
-            )
-
-        # Get only commits needed for tags and tracking branch
-        referenced_commit_shas = set()
-        for tag in all_tags:
-            referenced_commit_shas.add(tag.target_commit_sha)
-        if db_tracking_branch_entity:
-            referenced_commit_shas.add(db_tracking_branch_entity.head_commit_sha)
-
-        # Load only the referenced commits in chunks to avoid parameter limits
-        referenced_commits = []
-        referenced_files = []
-        if referenced_commit_shas:
-            commit_shas_list = list(referenced_commit_shas)
-            chunk_size = 1000
-
-            for i in range(0, len(commit_shas_list), chunk_size):
-                chunk = commit_shas_list[i : i + chunk_size]
-                chunk_commits = list(
-                    (
-                        await session.scalars(
-                            select(db_entities.GitCommit).where(
-                                db_entities.GitCommit.commit_sha.in_(chunk)
-                            )
-                        )
-                    ).all()
-                )
-                referenced_commits.extend(chunk_commits)
-
-            for i in range(0, len(commit_shas_list), chunk_size):
-                chunk = commit_shas_list[i : i + chunk_size]
-                chunk_files = list(
-                    (
-                        await session.scalars(
-                            select(db_entities.GitCommitFile).where(
-                                db_entities.GitCommitFile.commit_sha.in_(chunk)
-                            )
-                        )
-                    ).all()
-                )
-                referenced_files.extend(chunk_files)
 
-        return self._mapper.to_domain_git_repo(
-            db_repo=db_repo,
-            db_tracking_branch_entity=db_tracking_branch_entity,
-            db_commits=referenced_commits,
-            db_tags=all_tags,
-            db_commit_files=referenced_files,
-            db_tracking_branch=tracking_branch,
+    @staticmethod
+    def to_db(domain_entity: GitRepo) -> db_entities.GitRepo:
+        """Map domain entity to database entity."""
+        return db_entities.GitRepo(
+            sanitized_remote_uri=str(domain_entity.sanitized_remote_uri),
+            remote_uri=str(domain_entity.remote_uri),
+            cloned_path=domain_entity.cloned_path,
+            last_scanned_at=domain_entity.last_scanned_at,
+            num_commits=domain_entity.num_commits,
+            num_branches=domain_entity.num_branches,
+            num_tags=domain_entity.num_tags,
+            tracking_type=domain_entity.tracking_config.type,
+            tracking_name=domain_entity.tracking_config.name,
         )

kodit/infrastructure/sqlalchemy/git_tag_repository.py

@@ -2,13 +2,13 @@
 
 from collections.abc import Callable
 
-from sqlalchemy import delete, func, insert, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.domain.entities.git import GitCommit, GitFile, GitTag
+from kodit.domain.entities.git import GitTag
 from kodit.domain.protocols import GitTagRepository
 from kodit.infrastructure.sqlalchemy import entities as db_entities
-from kodit.infrastructure.sqlalchemy.unit_of_work import SqlAlchemyUnitOfWork
+from kodit.infrastructure.sqlalchemy.query import FilterOperator, QueryBuilder
+from kodit.infrastructure.sqlalchemy.repository import SqlAlchemyRepository
 
 
 def create_git_tag_repository(
@@ -18,251 +18,64 @@ def create_git_tag_repository(
     return SqlAlchemyGitTagRepository(session_factory=session_factory)
 
 
-class SqlAlchemyGitTagRepository(GitTagRepository):
+class SqlAlchemyGitTagRepository(
+    SqlAlchemyRepository[GitTag, db_entities.GitTag], GitTagRepository
+):
     """SQLAlchemy implementation of GitTagRepository."""
 
-    def __init__(self, session_factory: Callable[[], AsyncSession]) -> None:
-        """Initialize the repository."""
-        self.session_factory = session_factory
+    def _get_id(self, entity: GitTag) -> tuple[int, str]:
+        """Get the ID of a tag."""
+        if entity.repo_id is None:
+            raise ValueError("Repository ID is required")
+        return (entity.repo_id, entity.name)
+
+    @property
+    def db_entity_type(self) -> type[db_entities.GitTag]:
+        """The SQLAlchemy model type."""
+        return db_entities.GitTag
+
+    @staticmethod
+    def to_domain(db_entity: db_entities.GitTag) -> GitTag:
+        """Map a SQLAlchemy GitTag to a domain GitTag."""
+        return GitTag(
+            created_at=db_entity.created_at,
+            updated_at=db_entity.updated_at,
+            repo_id=db_entity.repo_id,
+            name=db_entity.name,
+            target_commit_sha=db_entity.target_commit_sha,
+        )
+
+    @staticmethod
+    def to_db(domain_entity: GitTag) -> db_entities.GitTag:
+        """Map a domain GitTag to a SQLAlchemy GitTag."""
+        if domain_entity.repo_id is None:
+            raise ValueError("Repository ID is required")
+        return db_entities.GitTag(
+            repo_id=domain_entity.repo_id,
+            name=domain_entity.name,
+            target_commit_sha=domain_entity.target_commit_sha,
+        )
 
     async def get_by_name(self, tag_name: str, repo_id: int) -> GitTag:
         """Get a tag by name and repository ID."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # Get the tag
-            stmt = select(db_entities.GitTag).where(
-                db_entities.GitTag.name == tag_name,
-                db_entities.GitTag.repo_id == repo_id,
-            )
-            db_tag = await session.scalar(stmt)
-            if not db_tag:
-                raise ValueError(f"Tag {tag_name} not found in repo {repo_id}")
-
-            # Get the target commit
-            commit_stmt = select(db_entities.GitCommit).where(
-                db_entities.GitCommit.commit_sha == db_tag.target_commit_sha
-            )
-            db_commit = await session.scalar(commit_stmt)
-            if not db_commit:
-                raise ValueError(f"Target commit {db_tag.target_commit_sha} not found")
-
-            # Get files for the target commit
-            files_stmt = select(db_entities.GitCommitFile).where(
-                db_entities.GitCommitFile.commit_sha == db_tag.target_commit_sha
-            )
-            db_files = (await session.scalars(files_stmt)).all()
-
-            domain_files = []
-            for db_file in db_files:
-                domain_file = GitFile(
-                    blob_sha=db_file.blob_sha,
-                    path=db_file.path,
-                    mime_type=db_file.mime_type,
-                    size=db_file.size,
-                    extension=db_file.extension,
-                    created_at=db_file.created_at,
-                )
-                domain_files.append(domain_file)
-
-            target_commit = GitCommit(
-                commit_sha=db_commit.commit_sha,
-                date=db_commit.date,
-                message=db_commit.message,
-                parent_commit_sha=db_commit.parent_commit_sha,
-                files=domain_files,
-                author=db_commit.author,
-                created_at=db_commit.created_at,
-                updated_at=db_commit.updated_at,
-            )
-
-            return GitTag(
-                repo_id=db_tag.repo_id,
-                name=db_tag.name,
-                target_commit=target_commit,
-                created_at=db_tag.created_at,
-                updated_at=db_tag.updated_at,
-            )
+        query = (
+            QueryBuilder()
+            .filter("name", FilterOperator.EQ, tag_name)
+            .filter("repo_id", FilterOperator.EQ, repo_id)
+        )
+        tags = await self.find(query)
+        if not tags:
+            raise ValueError(f"Tag {tag_name} not found in repo {repo_id}")
+        return tags[0]
 
     async def get_by_repo_id(self, repo_id: int) -> list[GitTag]:
         """Get all tags for a repository."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # Get all tags for the repo
-            tags_stmt = select(db_entities.GitTag).where(
-                db_entities.GitTag.repo_id == repo_id
-            )
-            db_tags = (await session.scalars(tags_stmt)).all()
-
-            if not db_tags:
-                return []
-
-            commit_shas = [tag.target_commit_sha for tag in db_tags]
-
-            # Get all target commits for these tags in chunks
-            # to avoid parameter limits
-            db_commits: list[db_entities.GitCommit] = []
-            chunk_size = 1000
-            for i in range(0, len(commit_shas), chunk_size):
-                chunk = commit_shas[i : i + chunk_size]
-                commits_stmt = select(db_entities.GitCommit).where(
-                    db_entities.GitCommit.commit_sha.in_(chunk)
-                )
-                chunk_commits = (await session.scalars(commits_stmt)).all()
-                db_commits.extend(chunk_commits)
-
-            # Get all files for these commits in chunks
-            # to avoid parameter limits
-            db_files: list[db_entities.GitCommitFile] = []
-            for i in range(0, len(commit_shas), chunk_size):
-                chunk = commit_shas[i : i + chunk_size]
-                files_stmt = select(db_entities.GitCommitFile).where(
-                    db_entities.GitCommitFile.commit_sha.in_(chunk)
-                )
-                chunk_files = (await session.scalars(files_stmt)).all()
-                db_files.extend(chunk_files)
-
-            # Group files by commit SHA
-            files_by_commit: dict[str, list[GitFile]] = {}
-            for db_file in db_files:
-                if db_file.commit_sha not in files_by_commit:
-                    files_by_commit[db_file.commit_sha] = []
-
-                domain_file = GitFile(
-                    blob_sha=db_file.blob_sha,
-                    path=db_file.path,
-                    mime_type=db_file.mime_type,
-                    size=db_file.size,
-                    extension=db_file.extension,
-                    created_at=db_file.created_at,
-                )
-                files_by_commit[db_file.commit_sha].append(domain_file)
-
-            # Create commit lookup
-            commits_by_sha = {commit.commit_sha: commit for commit in db_commits}
-
-            # Create domain tags
-            domain_tags = []
-            for db_tag in db_tags:
-                db_commit = commits_by_sha.get(db_tag.target_commit_sha)
-                if not db_commit:
-                    continue
-
-                commit_files = files_by_commit.get(db_tag.target_commit_sha, [])
-                target_commit = GitCommit(
-                    commit_sha=db_commit.commit_sha,
-                    date=db_commit.date,
-                    message=db_commit.message,
-                    parent_commit_sha=db_commit.parent_commit_sha,
-                    files=commit_files,
-                    author=db_commit.author,
-                    created_at=db_commit.created_at,
-                    updated_at=db_commit.updated_at,
-                )
-
-                domain_tag = GitTag(
-                    repo_id=db_tag.repo_id,
-                    name=db_tag.name,
-                    target_commit=target_commit,
-                    created_at=db_tag.created_at,
-                    updated_at=db_tag.updated_at,
-                )
-                domain_tags.append(domain_tag)
-
-            return domain_tags
-
-    async def save(self, tag: GitTag, repo_id: int) -> GitTag:
-        """Save a tag to a repository."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # Set repo_id on the tag
-            tag.repo_id = repo_id
-
-            # Check if tag already exists
-            existing_tag = await session.get(
-                db_entities.GitTag, (repo_id, tag.name)
-            )
-
-            if existing_tag:
-                # Update existing tag
-                existing_tag.target_commit_sha = tag.target_commit.commit_sha
-                if tag.updated_at:
-                    existing_tag.updated_at = tag.updated_at
-            else:
-                # Create new tag
-                db_tag = db_entities.GitTag(
-                    repo_id=repo_id,
-                    name=tag.name,
-                    target_commit_sha=tag.target_commit.commit_sha,
-                )
-                session.add(db_tag)
-
-            return tag
-
-    async def save_bulk(self, tags: list[GitTag], repo_id: int) -> None:
-        """Bulk save tags to a repository."""
-        if not tags:
-            return
-
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # Get existing tags in bulk
-            existing_tags_stmt = select(db_entities.GitTag).where(
-                db_entities.GitTag.repo_id == repo_id,
-                db_entities.GitTag.name.in_([tag.name for tag in tags]),
-            )
-            existing_tags = (await session.scalars(existing_tags_stmt)).all()
-            existing_tag_names = {tag.name for tag in existing_tags}
-
-            # Update existing tags
-            for existing_tag in existing_tags:
-                for tag in tags:
-                    if (
-                        tag.name == existing_tag.name
-                        and existing_tag.target_commit_sha
-                        != tag.target_commit.commit_sha
-                    ):
-                        existing_tag.target_commit_sha = tag.target_commit.commit_sha
-                        break
-
-            # Prepare new tags for bulk insert
-            new_tags_data = [
-                {
-                    "repo_id": repo_id,
-                    "name": tag.name,
-                    "target_commit_sha": tag.target_commit.commit_sha,
-                }
-                for tag in tags
-                if tag.name not in existing_tag_names
-            ]
-
-            # Bulk insert new tags in chunks to avoid parameter limits
-            if new_tags_data:
-                chunk_size = 1000  # Conservative chunk size for parameter limits
-                for i in range(0, len(new_tags_data), chunk_size):
-                    chunk = new_tags_data[i : i + chunk_size]
-                    stmt = insert(db_entities.GitTag).values(chunk)
-                    await session.execute(stmt)
-
-    async def exists(self, tag_name: str, repo_id: int) -> bool:
-        """Check if a tag exists."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            stmt = select(db_entities.GitTag.name).where(
-                db_entities.GitTag.name == tag_name,
-                db_entities.GitTag.repo_id == repo_id,
-            )
-            result = await session.scalar(stmt)
-            return result is not None
+        return await self.find(
+            QueryBuilder().filter("repo_id", FilterOperator.EQ, repo_id)
+        )
 
     async def delete_by_repo_id(self, repo_id: int) -> None:
         """Delete all tags for a repository."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            # Delete tags
-            del_tags_stmt = delete(db_entities.GitTag).where(
-                db_entities.GitTag.repo_id == repo_id
-            )
-            await session.execute(del_tags_stmt)
-
-    async def count_by_repo_id(self, repo_id: int) -> int:
-        """Count the number of tags for a repository."""
-        async with SqlAlchemyUnitOfWork(self.session_factory) as session:
-            stmt = select(func.count()).select_from(db_entities.GitTag).where(
-                db_entities.GitTag.repo_id == repo_id
-            )
-            result = await session.scalar(stmt)
-            return result or 0
+        await self.delete_by_query(
+            QueryBuilder().filter("repo_id", FilterOperator.EQ, repo_id)
+        )