abs-integration-core 0.1.0__tar.gz

abs_integration_core-0.1.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.3
+Name: abs-integration-core
+Version: 0.1.0
+Summary: Core utilities for building OAuth-based integrations in FastAPI applications
+License: MIT
+Author: AutoBridgeSystems
+Author-email: info@autobridgesystems.com
+Requires-Python: >=3.13,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: abs-exception-core (>=0.1.2,<0.2.0)
+Requires-Dist: abs-repository-core (>=0.2.2,<0.3.0)
+Requires-Dist: fastapi (>=0.95.0,<2.0.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: sqlalchemy (>=2.0.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Integration Core
+
+A core library for building and managing OAuth-based third-party integrations in FastAPI applications.
+
+## Overview
+
+`abs-integration-core` provides a set of reusable components to simplify the implementation of OAuth-based integrations with third-party services. It includes models, schemas, repositories, and a base service class that can be extended for specific integration providers.
+
+## Features
+
+- **Integration Model**: SQLAlchemy model for storing OAuth tokens and integration metadata
+- **Standard Schemas**: Pydantic models for integration data validation and serialization
+- **Repository Layer**: Data access layer for CRUD operations on integration records
+- **Base Service**: Abstract base class for implementing integration services for different providers
+
+## Installation
+
+```bash
+pip install abs-integration-core
+```
+
+## Dependencies
+
+This package depends on:
+
+- `fastapi`: For API routing and endpoint handling
+- `sqlalchemy`: For database ORM functionality
+- `pydantic`: For data validation
+- `abs-exception-core`: For standardized exception handling
+- `abs-repository-core`: For base repository pattern implementation
+- `abs-auth-rbac-core`: For authentication and base models
+
+## Usage
+
+### Models
+
+The core model represents an OAuth integration with a third-party provider:
+
+```python
+from abs_integration_core.models import Integration
+
+# The Integration model includes:
+# - provider_name: String(255)
+# - access_token: Text
+# - refresh_token: Text  
+# - expires_in: Integer
+```
+
+### Schemas
+
+Various Pydantic schemas are available for request/response handling:
+
+```python
+from abs_integration_core import (
+    TokenData,
+    IsConnectedResponse,
+    CreateIntegration,
+    UpdateIntegration,
+    ResponseSchema
+)
+
+# Example: Create a standard API response
+response = ResponseSchema(
+    status=200,
+    message="Integration created successfully",
+    data=IsConnectedResponse(provider="sharepoint", connected=True)
+)
+```
+
+### Repository
+
+The `IntegrationRepository` provides data access methods:
+
+```python
+from abs_integration_core import IntegrationRepository
+
+# Initialize repository with a database session factory
+repo = IntegrationRepository(db_session)
+
+# Available methods:
+# - create_integration(integration_data)
+# - update_integration(integration_id, update_data)
+# - get_by_provider(provider_name)
+# - get_all()
+# - delete_by_provider(provider_name)
+# - refresh_token(provider_name, new_access_token, new_refresh_token, new_expires_in)
+```
+
+### Base Service
+
+Extend the `IntegrationBaseService` to implement provider-specific integration services:
+
+```python
+from abs_integration_core import IntegrationBaseService
+
+class SharepointIntegrationService(IntegrationBaseService):
+    def __init__(self, provider_name, integration_repository):
+        super().__init__(provider_name, integration_repository)
+    
+    def get_auth_url(self):
+        # Implementation for generating OAuth URL
+        
+    async def get_token_data(self, code):
+        # Implementation for exchanging code for tokens
+        
+    async def handle_oauth_callback(self, code):
+        # Implementation for processing OAuth callback
+        
+    async def refresh_token(self):
+        # Implementation for refreshing tokens
+```
+
+## Implementing a New Integration
+
+To implement a new integration provider:
+
+1. Create a new service class that extends `IntegrationBaseService`
+2. Implement the required abstract methods:
+   - `get_auth_url()`
+   - `get_token_data(code)`
+   - `handle_oauth_callback(code)`
+   - `refresh_token()`
+3. Register your service in your FastAPI application
+4. Create API routes to initiate auth flow, handle callbacks, etc.
+
+## Example: Creating API Routes
+
+```python
+from fastapi import APIRouter, Depends
+from abs_integration_core import ResponseSchema, IsConnectedResponse
+
+router = APIRouter(prefix="/integration", tags=["integration"])
+
+@router.get("/{provider_name}/connect")
+async def integration_connect(
+    service: IntegrationBaseService = Depends(get_integration_service)
+):
+    auth_data = service.get_auth_url()
+    return RedirectResponse(url=auth_data["auth_url"])
+
+@router.get("/{provider_name}/callback")
+async def integration_callback(
+    code: str,
+    service: IntegrationBaseService = Depends(get_integration_service)
+):
+    token_data = await service.handle_oauth_callback(code)
+    return ResponseSchema(
+        data=IsConnectedResponse(
+            provider=service.provider_name,
+            connected=True
+        ),
+        message=f"Integration connected successfully"
+    )
+```
+
+## License
+
+MIT 

abs_integration_core-0.1.0/README.md

@@ -0,0 +1,158 @@
+# Integration Core
+
+A core library for building and managing OAuth-based third-party integrations in FastAPI applications.
+
+## Overview
+
+`abs-integration-core` provides a set of reusable components to simplify the implementation of OAuth-based integrations with third-party services. It includes models, schemas, repositories, and a base service class that can be extended for specific integration providers.
+
+## Features
+
+- **Integration Model**: SQLAlchemy model for storing OAuth tokens and integration metadata
+- **Standard Schemas**: Pydantic models for integration data validation and serialization
+- **Repository Layer**: Data access layer for CRUD operations on integration records
+- **Base Service**: Abstract base class for implementing integration services for different providers
+
+## Installation
+
+```bash
+pip install abs-integration-core
+```
+
+## Dependencies
+
+This package depends on:
+
+- `fastapi`: For API routing and endpoint handling
+- `sqlalchemy`: For database ORM functionality
+- `pydantic`: For data validation
+- `abs-exception-core`: For standardized exception handling
+- `abs-repository-core`: For base repository pattern implementation
+- `abs-auth-rbac-core`: For authentication and base models
+
+## Usage
+
+### Models
+
+The core model represents an OAuth integration with a third-party provider:
+
+```python
+from abs_integration_core.models import Integration
+
+# The Integration model includes:
+# - provider_name: String(255)
+# - access_token: Text
+# - refresh_token: Text  
+# - expires_in: Integer
+```
+
+### Schemas
+
+Various Pydantic schemas are available for request/response handling:
+
+```python
+from abs_integration_core import (
+    TokenData,
+    IsConnectedResponse,
+    CreateIntegration,
+    UpdateIntegration,
+    ResponseSchema
+)
+
+# Example: Create a standard API response
+response = ResponseSchema(
+    status=200,
+    message="Integration created successfully",
+    data=IsConnectedResponse(provider="sharepoint", connected=True)
+)
+```
+
+### Repository
+
+The `IntegrationRepository` provides data access methods:
+
+```python
+from abs_integration_core import IntegrationRepository
+
+# Initialize repository with a database session factory
+repo = IntegrationRepository(db_session)
+
+# Available methods:
+# - create_integration(integration_data)
+# - update_integration(integration_id, update_data)
+# - get_by_provider(provider_name)
+# - get_all()
+# - delete_by_provider(provider_name)
+# - refresh_token(provider_name, new_access_token, new_refresh_token, new_expires_in)
+```
+
+### Base Service
+
+Extend the `IntegrationBaseService` to implement provider-specific integration services:
+
+```python
+from abs_integration_core import IntegrationBaseService
+
+class SharepointIntegrationService(IntegrationBaseService):
+    def __init__(self, provider_name, integration_repository):
+        super().__init__(provider_name, integration_repository)
+    
+    def get_auth_url(self):
+        # Implementation for generating OAuth URL
+        
+    async def get_token_data(self, code):
+        # Implementation for exchanging code for tokens
+        
+    async def handle_oauth_callback(self, code):
+        # Implementation for processing OAuth callback
+        
+    async def refresh_token(self):
+        # Implementation for refreshing tokens
+```
+
+## Implementing a New Integration
+
+To implement a new integration provider:
+
+1. Create a new service class that extends `IntegrationBaseService`
+2. Implement the required abstract methods:
+   - `get_auth_url()`
+   - `get_token_data(code)`
+   - `handle_oauth_callback(code)`
+   - `refresh_token()`
+3. Register your service in your FastAPI application
+4. Create API routes to initiate auth flow, handle callbacks, etc.
+
+## Example: Creating API Routes
+
+```python
+from fastapi import APIRouter, Depends
+from abs_integration_core import ResponseSchema, IsConnectedResponse
+
+router = APIRouter(prefix="/integration", tags=["integration"])
+
+@router.get("/{provider_name}/connect")
+async def integration_connect(
+    service: IntegrationBaseService = Depends(get_integration_service)
+):
+    auth_data = service.get_auth_url()
+    return RedirectResponse(url=auth_data["auth_url"])
+
+@router.get("/{provider_name}/callback")
+async def integration_callback(
+    code: str,
+    service: IntegrationBaseService = Depends(get_integration_service)
+):
+    token_data = await service.handle_oauth_callback(code)
+    return ResponseSchema(
+        data=IsConnectedResponse(
+            provider=service.provider_name,
+            connected=True
+        ),
+        message=f"Integration connected successfully"
+    )
+```
+
+## License
+
+MIT 

abs_integration_core-0.1.0/abs_integration_core/models/__init__.py

@@ -0,0 +1,3 @@
+from .integration_model import Integration
+
+__all__ = ["Integration"]

abs_integration_core-0.1.0/abs_integration_core/models/integration_model.py

@@ -0,0 +1,14 @@
+from sqlalchemy import Column, String, Integer, Text
+from sqlalchemy.orm import relationship
+
+from abs_repository_core.models import BaseModel
+
+
+class Integration(BaseModel):
+    """Integration model"""
+    __tablename__ = "gov_integrations"
+
+    provider_name = Column(String(255), nullable=False)
+    access_token = Column(Text, nullable=False)
+    refresh_token = Column(Text, nullable=False)
+    expires_in = Column(Integer, nullable=False)

abs_integration_core-0.1.0/abs_integration_core/repository/__init__.py

@@ -0,0 +1,3 @@
+from .integration_repository import IntegrationRepository
+
+__all__ = ["IntegrationRepository"]

abs_integration_core-0.1.0/abs_integration_core/repository/integration_repository.py

@@ -0,0 +1,61 @@
+from abs_repository_core.repository import BaseRepository
+from abs_integration_core.models import Integration
+from typing import Callable
+from sqlalchemy.orm import Session
+from abs_integration_core.schema import CreateIntegration
+from abs_integration_core.schema import TokenData
+
+class IntegrationRepository(BaseRepository):
+    def __init__(self, db: Callable[..., Session]):
+        self.db = db
+        super().__init__(db, Integration)
+    
+    def create_integration(self, integration_data: CreateIntegration) -> Integration:
+        """
+        Create a new integration record.
+        
+        Args:
+            integration_data: Integration data including provider_name, access_token, etc.
+            
+        Returns:
+            The created integration object
+            
+        Raises:
+            DuplicatedError: If integration with same provider already exists
+        """
+        new_integration = Integration(
+            provider_name=integration_data.provider_name,
+            access_token=integration_data.access_token,
+            refresh_token=integration_data.refresh_token,
+            expires_in=integration_data.expires_in
+        )
+        
+        integration = super().create(new_integration)
+        return integration
+    
+    def refresh_token(
+        self,
+        provider_name: str, 
+        token_data: TokenData
+    ) -> Integration:
+        """
+        Update token information for a specific integration.
+        
+        Args:
+            provider_name: The integration provider name
+            token_data: The data to update
+            
+        Returns:
+            The updated integration object
+            
+        Raises:
+            NotFoundError: If integration doesn't exist
+        """
+        integration = super().read_by_attr(
+            attr="provider_name",
+            value=provider_name
+        )
+        
+        super().update(integration.id, token_data)
+
+        return integration

abs_integration_core-0.1.0/abs_integration_core/schema/__init__.py

@@ -0,0 +1,17 @@
+from .common_schema import ResponseSchema
+from .integration_schema import (
+    TokenData, 
+    Integration, 
+    IsConnectedResponse, 
+    CreateIntegration, 
+    UpdateIntegration
+)
+
+__all__ = [
+    "ResponseSchema",
+    "TokenData",
+    "Integration",
+    "IsConnectedResponse",
+    "CreateIntegration",
+    "UpdateIntegration"
+]

abs_integration_core-0.1.0/abs_integration_core/schema/common_schema.py

@@ -0,0 +1,17 @@
+from typing import Generic, Optional, TypeVar
+from pydantic import BaseModel
+from fastapi import status
+
+T = TypeVar('T')
+
+
+class ResponseSchema(BaseModel, Generic[T]):
+    """
+    Standard response schema for all API endpoints
+    """
+    status: int = status.HTTP_200_OK
+    message: str = "Success"
+    data: Optional[T] = None
+
+    class Config:
+        arbitrary_types_allowed = True

abs_integration_core-0.1.0/abs_integration_core/schema/integration_schema.py

@@ -0,0 +1,42 @@
+from abs_repository_core.schemas import ModelBaseInfo, make_optional
+from pydantic import BaseModel
+from typing import Optional
+
+
+class TokenData(BaseModel):
+    access_token: str
+    refresh_token: str
+    expires_in: int
+    
+    class Config:
+        extra = "allow"
+
+
+class Integration(make_optional(ModelBaseInfo), TokenData):
+    provider_name: str
+
+
+class IsConnectedResponse(BaseModel):
+    provider: str
+    connected: bool
+    
+    class Config:
+        extra = "allow"
+
+
+class CreateIntegration(BaseModel):
+    """Model for creating a new integration"""
+    provider_name: str
+    access_token: str
+    refresh_token: str
+    expires_in: int
+
+
+class UpdateIntegration(BaseModel):
+    """Model for updating an existing integration"""
+    access_token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    expires_in: Optional[int] = None
+
+    class Config:
+        extra = "ignore"

abs_integration_core-0.1.0/abs_integration_core/service/__init__.py

@@ -0,0 +1,3 @@
+from .base_service import IntegrationBaseService
+
+__all__ = ["IntegrationBaseService"]

abs_integration_core-0.1.0/abs_integration_core/service/base_service.py

@@ -0,0 +1,125 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, List
+from abs_integration_core.schema import TokenData, Integration
+from abs_integration_core.repository import IntegrationRepository
+from abs_exception_core.exceptions import NotFoundError
+from abs_repository_core.services.base_service import BaseService
+from abs_integration_core.utils.encryption import Encryption
+
+
+class IntegrationBaseService(ABC, BaseService):
+    """
+    Base abstract class for all integration services.
+    Any integration service should inherit from this class and implement its methods.
+    """
+    def __init__(
+        self, 
+        provider_name: str, 
+        integration_repository: IntegrationRepository,
+        encryption: Encryption
+    ):
+        self.provider_name = provider_name
+        self.encryption = encryption
+        super().__init__(integration_repository)
+
+    @abstractmethod
+    def get_auth_url(self, state: Optional[Dict] = None) -> Dict[str, str]:
+        """
+        Generate an authentication URL for OAuth flow.
+        
+        Args:
+            state: Optional state dictionary to include in the OAuth flow
+        
+        Returns:
+            A dictionary containing the auth URL and other necessary information
+        """
+        pass
+
+    @abstractmethod
+    async def get_token_data(self, code: str) -> TokenData:
+        """
+        Exchange authorization code for token data.
+        
+        Args:
+            code: The authorization code from OAuth callback
+            
+        Returns:
+            TokenData object with access_token, refresh_token and expires_in
+        """
+        pass
+
+    @abstractmethod
+    async def handle_oauth_callback(self, code: str) -> TokenData:
+        """
+        Handle the OAuth callback and store tokens.
+        
+        Args:
+            code: The authorization code from OAuth callback
+            
+        Returns:
+            TokenData object
+        """
+        pass
+
+    @abstractmethod
+    async def refresh_token(self) -> Optional[TokenData]:
+        """
+        Refresh the access token using the refresh token.
+        
+        Returns:
+            Updated TokenData if successful, None otherwise
+        """
+        pass
+
+    def get_query_by_provider(self):
+        return super().get_by_attr(
+            attr="provider_name",
+            value=self.provider_name
+        )
+
+    def get_integration(self) -> Optional[TokenData]:
+        """
+        Get integration data.
+        
+        Returns:
+            TokenData if integration exists, None otherwise
+        """
+        try:
+            integration = self.get_query_by_provider()
+            return integration
+        except Exception:
+            return None
+
+    def get_all_integrations(self) -> List[Integration]:
+        """
+        Get all integrations.
+        
+        Returns:
+            List of TokenData objects
+        """
+        try:
+            integrations = super().get_list()
+            return integrations
+        except Exception:
+            return []
+
+    def delete_integration(self) -> bool:
+        """
+        Delete an integration.
+        
+        Returns:
+            True if deleted, False otherwise
+        """
+        try:
+            integration = self.get_query_by_provider()
+            super().remove_by_id(integration.id)
+
+            return True
+
+        except NotFoundError:
+            # If the integration doesn't exist, consider it "deleted"
+            return True
+
+        except Exception as e:
+            print(f"Error deleting integration: {str(e)}")
+            return False

abs_integration_core-0.1.0/abs_integration_core/utils/encryption.py

@@ -0,0 +1,98 @@
+from cryptography.fernet import Fernet
+import base64
+import hashlib
+from typing import Optional
+
+
+class Encryption:
+    def __init__(self, key: Optional[str] = None):
+        self.key = key
+
+    # Encryption key management
+    def get_encryption_key(self):
+        """
+        Get encryption key from environment variable or generate one if not exists
+        
+        This should ideally be set in environment variables and consistent across restarts
+        Returns:
+            A valid Fernet key (32 url-safe base64-encoded bytes)
+        """
+
+        if not self.key:
+            # For demo only - in production, you should set a permanent key
+            # and store it securely in environment variables or a secret manager
+            self.key = Fernet.generate_key().decode()
+            print(f"WARNING: Generated temporary encryption key: {self.key}")
+            print("Set this in your environment as TOKEN_ENCRYPTION_KEY")
+            return self.key.encode() if isinstance(self.key, str) else self.key
+        
+        # If key is not in valid Fernet format, convert it to a valid key
+        try:
+            # Try to use the key as is - if it's already a valid Fernet key
+            if isinstance(self.key, str):
+                self.key = self.key.encode()
+                
+            # Test if it's a valid key
+            Fernet(self.key)
+            return self.key
+        except Exception:
+            # Not a valid Fernet key - convert to a valid one
+            # Use SHA-256 to get a consistent length, then encode in base64
+            if isinstance(self.key, str):
+                self.key = self.key.encode()
+                
+            hashed_key = hashlib.sha256(self.key).digest()
+            encoded_key = base64.urlsafe_b64encode(hashed_key)
+            
+            print("WARNING: Converted invalid encryption key to valid Fernet format")
+            return encoded_key
+
+    def encrypt_token(self, token: str) -> str:
+        """
+        Encrypt a token string using Fernet symmetric encryption
+        
+        Args:
+            token: The raw token string to encrypt
+            
+        Returns:
+            The encrypted token as a base64 string
+        """
+        if not token:
+            return token
+            
+        # Get the encryption key
+        key = self.get_encryption_key()
+        
+        # Create a Fernet cipher
+        cipher = Fernet(key)
+        
+        # Encrypt the token (which must be bytes)
+        encrypted_token = cipher.encrypt(token.encode())
+        
+        # Return as a string for storage
+        return encrypted_token.decode()
+
+    def decrypt_token(self, encrypted_token: str) -> str:
+        """
+        Decrypt a token string that was encrypted with Fernet
+        
+        Args:
+            encrypted_token: The encrypted token as a base64 string
+            
+        Returns:
+            The original decrypted token string
+        """
+        if not encrypted_token:
+            return encrypted_token
+            
+        # Get the encryption key
+        key = self.get_encryption_key()
+        
+        # Create a Fernet cipher
+        cipher = Fernet(key)
+        
+        # Decrypt the token (convert string to bytes first)
+        decrypted_token = cipher.decrypt(encrypted_token.encode())
+        
+        # Return as a string
+        return decrypted_token.decode()

abs_integration_core-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "abs-integration-core"
+version = "0.1.0"
+description = "Core utilities for building OAuth-based integrations in FastAPI applications"
+authors = [
+    {name = "AutoBridgeSystems", email = "info@autobridgesystems.com"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.13,<4.0"
+dependencies = [
+    "fastapi >=0.95.0,<2.0.0",
+    "sqlalchemy >=2.0.0,<3.0.0",
+    "pydantic >=2.0.0,<3.0.0",
+    "abs-exception-core (>=0.1.2,<0.2.0)",
+    "abs-repository-core (>=0.2.2,<0.3.0)",
+]
+
+[tool.poetry]
+packages = [
+    { include = "abs_integration_core" }
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"