kodit 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

kodit/infrastructure/sqlalchemy/git_repository.py

@@ -0,0 +1,252 @@
+"""SQLAlchemy implementation of GitRepoRepository."""
+
+from collections.abc import Callable
+
+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.protocols import GitRepoRepository
+from kodit.infrastructure.mappers.git_mapper import GitMapper
+from kodit.infrastructure.sqlalchemy import entities as db_entities
+from kodit.infrastructure.sqlalchemy.unit_of_work import SqlAlchemyUnitOfWork
+
+
+def create_git_repo_repository(
+    session_factory: Callable[[], AsyncSession],
+) -> GitRepoRepository:
+    """Create a git repository."""
+    return SqlAlchemyGitRepoRepository(session_factory=session_factory)
+
+
+class SqlAlchemyGitRepoRepository(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
+
+    @property
+    def _mapper(self) -> GitMapper:
+        return GitMapper()
+
+    async def save(self, repo: GitRepo) -> GitRepo:
+        """Save or update a repository with all its branches, commits, and tags."""
+        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)
+            )
+            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
+            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)
+
+            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()
+        )
+        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
+        referenced_commits = []
+        referenced_files = []
+        if referenced_commit_shas:
+            referenced_commits = list(
+                (
+                    await session.scalars(
+                        select(db_entities.GitCommit).where(
+                            db_entities.GitCommit.commit_sha.in_(referenced_commit_shas)
+                        )
+                    )
+                ).all()
+            )
+            referenced_files = list(
+                (
+                    await session.scalars(
+                        select(db_entities.GitCommitFile).where(
+                            db_entities.GitCommitFile.commit_sha.in_(referenced_commit_shas)
+                        )
+                    )
+                ).all()
+            )
+
+        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,
+        )

kodit/infrastructure/sqlalchemy/git_tag_repository.py

@@ -0,0 +1,257 @@
+"""SQLAlchemy implementation of GitTagRepository."""
+
+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.protocols import GitTagRepository
+from kodit.infrastructure.sqlalchemy import entities as db_entities
+from kodit.infrastructure.sqlalchemy.unit_of_work import SqlAlchemyUnitOfWork
+
+
+def create_git_tag_repository(
+    session_factory: Callable[[], AsyncSession],
+) -> GitTagRepository:
+    """Create a git tag repository."""
+    return SqlAlchemyGitTagRepository(session_factory=session_factory)
+
+
+class SqlAlchemyGitTagRepository(GitTagRepository):
+    """SQLAlchemy implementation of GitTagRepository."""
+
+    def __init__(self, session_factory: Callable[[], AsyncSession]) -> None:
+        """Initialize the repository."""
+        self.session_factory = session_factory
+
+    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,
+            )
+
+    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
+            commits_stmt = select(db_entities.GitCommit).where(
+                db_entities.GitCommit.commit_sha.in_(commit_shas)
+            )
+            db_commits = (await session.scalars(commits_stmt)).all()
+
+            # Get all files for these commits
+            files_stmt = select(db_entities.GitCommitFile).where(
+                db_entities.GitCommitFile.commit_sha.in_(commit_shas)
+            )
+            db_files = (await session.scalars(files_stmt)).all()
+
+            # 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
+
+    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