contentgrid-extension-helpers 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

contentgrid_extension_helpers/authentication/user.py

@@ -1,4 +1,5 @@
-from pydantic import BaseModel
+from typing import List
+from pydantic import BaseModel, Field
 
 class ContentGridUser(BaseModel):
     sub: str
@@ -6,4 +7,29 @@ class ContentGridUser(BaseModel):
     exp: float
     name: str | None = None
     email: str | None = None
-    access_token: str
+    access_token: str
+    domains : List[str] = Field(validation_alias="context:application:domains")
+    application_id : str = Field(validation_alias="context:application:id")
+    
+    
+    
+if __name__ == "__main__":
+    user = ContentGridUser(
+        **{
+            "sub": "https://auth.sandbox.contentgrid.cloud/realms/cg-77594d8b-9bc9-40ed-b2a8-9c03a2905a20#d91e9a4d-8447-4bf1-8d10-339b2e5951ea",
+            "aud": "contentgrid:extension:extract",
+            "restrict:principal_claims": "24ZPEGV0IS5MAF8C2BjmaqH1p7wL4YS409zlL8ZE+nEUHsFFDu80eDpJXoFvZIb1Hh9bxamGaK0gE14wvA+btCuDrg5lkGcdCVj3zm/RWnIFKzlGUVn7Zkj4z4PCzsq/itKVNXEYBtAS/d0NRFSiZGvy775kFdK1VOi+hxsic1bHAZTvSs1jEFuddxEULExh2MqZ5h43n/vEhB0sxkmXevR7XSE4iolDzCWGrw6HzUZYP/QlSlz/S3cK+aeoShAP1G2SbuTGub5h1fsKMM22eg==",
+            "iss": "https://extensions.sandbox.contentgrid.cloud/authentication/external",
+            "may_act": {
+                "sub": "extract",
+                "iss": "https://auth.sandbox.contentgrid.cloud/realms/extensions"
+            },
+            "context:application:domains": [
+                "8be240cc-4581-43c2-96db-a8ccf8579e7d.sandbox.contentgrid.cloud"
+            ],
+            "exp": 1755775732,
+            "context:application:id": "8be240cc-4581-43c2-96db-a8ccf8579e7d",
+            "access_token" : "123"
+        }
+    )
+    print(user)

contentgrid_extension_helpers/config.py

@@ -0,0 +1,40 @@
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import List, Optional
+    
+# Pydantic settings is used throughout this file.
+# The library allows for easy configuration management, including environment variable loading and validation.
+# Each field can be configured to load from environment variables, and validation can be applied to ensure correct types and formats.
+# Example:
+# class MyConfig(BaseSettings):
+#     my_field: str = "default_value"
+#     my_required_bool: bool  # This field must be provided
+#     my_optional_field: Optional[int] = None
+# 
+# ENVIRONMENT VARIABLES:
+# MY_FIELD=my_value
+# MY_REQUIRED_BOOL=t
+# MY_OPTIONAL_FIELD=42
+# See https://docs.pydantic.dev/latest/api/pydantic_settings/ for more details.
+
+class ExtensionConfig(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=['.env', '.env.secret'],
+        env_file_encoding='utf-8',
+        extra='ignore',
+    )
+    
+    cors_origins : List[str] = [] # is taken into account if production is True
+
+    # Server Configuration
+    server_url: Optional[str] = None  # Base URL for the server, can be set to None for local development
+    server_host: Optional[str] = ""
+    server_port: Optional[int] = None
+    web_concurrency: Optional[int] = None
+    
+    # Environment Configuration
+    ci: bool = False
+    production: bool = False
+
+
+extension_config = ExtensionConfig()

contentgrid_extension_helpers/dependencies/authentication/user.py

@@ -0,0 +1,73 @@
+from typing import Optional, cast, TypeVar, Generic
+from fastapi import Depends
+from typing_extensions import Annotated
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings
+from contentgrid_extension_helpers.authentication.user import ContentGridUser
+from contentgrid_extension_helpers.authentication.oidc import create_current_user_dependency, get_oauth_jwks_client, create_oauth2_scheme
+
+oauth2_scheme = create_oauth2_scheme()
+
+UserModelType = TypeVar('UserModelType', bound=BaseModel)
+
+class ContentGridUserConfig(BaseSettings):
+    extension_name : str # Should be the same extension name as defined in tokenmonger and keycloak (without the contentgrid:extension: prefix)
+    oauth_issuer: str
+    extension_auth_url: str
+
+class ContentGridUserDependency(Generic[UserModelType]):
+    def __init__(
+        self,         
+        extension_name: Optional[str] = None,
+        oauth_issuer: Optional[str] = None,
+        custom_audience: Optional[str] = None,
+        user_model: type[UserModelType] = ContentGridUser,
+        algorithms: Optional[list[str]] = None,
+        verify_exp: bool = True,
+        verify_aud: bool = True,
+        verify_iss: bool = True,
+        verify_nbf: bool = False,
+        verify_iat: bool = False,
+    ) -> None:
+        
+        self.user_model = user_model
+        
+        # Create config dict with provided parameters
+        config_dict = {}
+        if extension_name is not None:
+            config_dict['extension_name'] = extension_name
+        if oauth_issuer is not None:
+            config_dict['oauth_issuer'] = oauth_issuer
+            
+        # Create ExtensionFlowConfig instance which will use env vars for missing values
+        self.user_config = ContentGridUserConfig(**config_dict)
+        
+        if not custom_audience:
+            self.audience = f"contentgrid:extension:{self.user_config.extension_name}"
+        else:
+            self.audience = custom_audience
+        
+        _ , self.jwks_client = get_oauth_jwks_client(self.user_config.oauth_issuer)
+                
+        self.user_dependency = create_current_user_dependency(
+            jwks_client=self.jwks_client,
+            oidc_issuer=self.user_config.oauth_issuer,
+            audience=self.audience,
+            user_model=user_model,
+            algorithms = algorithms,
+            verify_exp = verify_exp,
+            verify_aud = verify_aud,
+            verify_iss = verify_iss,
+            verify_nbf = verify_nbf,
+            verify_iat = verify_iat,
+        )
+    
+    @property
+    def config(self) -> ContentGridUserConfig:
+        return self.user_config
+
+    async def __call__(
+        self, token: Annotated[str, Depends(oauth2_scheme)]
+    ) -> UserModelType:
+        user = cast(UserModelType, await self.user_dependency(token))
+        return user

contentgrid_extension_helpers/dependencies/clients/contentgrid/__init__.py

@@ -0,0 +1,3 @@
+from .client_factory import ContentGridBaseClientFactory # noqa: F401
+from .service_account_factory import ContentGridServiceAccountFactory # noqa: F401
+from .extension_flow_factory import ContentGridExtensionFlowClientFactory # noqa: F401

contentgrid_extension_helpers/dependencies/clients/contentgrid/client_factory.py

@@ -0,0 +1,71 @@
+from abc import ABC
+from typing import Optional, TypeVar, List
+from contentgrid_hal_client.hal import HALFormsClient
+from fastapi import HTTPException, status
+from pydantic import HttpUrl
+from pydantic_settings import BaseSettings
+import logging
+
+
+T = TypeVar('T', bound=HALFormsClient)
+
+logger = logging.getLogger(__name__)
+
+class ContentGridClientFactorySettings(BaseSettings):
+    pass
+
+class ContentGridBaseClientFactory(ABC):
+    def __init__(self) -> None:
+        self.env_config = ContentGridClientFactorySettings()
+        
+    def _get_client_endpoint(
+        self,
+        origin: Optional[HttpUrl] = None,
+        allowed_domains: Optional[List[str]] = None,
+        default_endpoint: Optional[str] = None
+    ) -> str:
+        """
+        Get client endpoint with domain validation.
+        
+        Args:
+            origin: Origin URL to validate and use
+            allowed_domains: List of allowed domain strings for validation
+            default_endpoint: Default endpoint to use if no origin provided
+            user: ContentGrid user (optional, used for domain extraction if no allowed_domains)
+            
+        Returns:
+            Validated client endpoint URL
+            
+        Raises:
+            ValueError: If domain validation fails in production mode
+        """
+        if allowed_domains is None:
+            # No domains available, will rely on default_endpoint or production check
+            allowed_domains = []
+            
+        if origin:
+            origin_host = origin.host
+            origin_scheme = origin.scheme
+            endpoint = f"{origin_scheme}://{origin_host}"
+            
+            # Validate domain if we have allowed domains defined (even if empty)
+            if origin_host not in allowed_domains:
+                error_msg = f"Origin domain '{origin_host}' not in allowed domains: {allowed_domains}"
+                raise HTTPException(
+                    status_code=status.HTTP_403_FORBIDDEN,
+                    detail=error_msg, 
+                )
+            
+            return endpoint
+        
+        elif default_endpoint:
+            # Use default endpoint
+            return default_endpoint
+            
+        elif allowed_domains:
+            # Fallback to the first allowed domain
+            return "https://" + allowed_domains[0]
+            
+        else:
+            error_msg = "No endpoint available: provide either 'origin', 'default_endpoint', or ensure 'allowed_domains'/'user.domains' are available"
+            raise ValueError(error_msg)

contentgrid_extension_helpers/dependencies/clients/contentgrid/extension_flow_factory.py

@@ -0,0 +1,85 @@
+from typing import Annotated, Optional, Type, TypeVar
+
+from contentgrid_extension_helpers.authentication.user import ContentGridUser
+from fastapi import Depends, Query
+from contentgrid_extension_helpers.authentication.oidc import (
+    create_oauth2_scheme,
+)
+from contentgrid_application_client.application import ContentGridApplicationClient
+from contentgrid_hal_client.hal import HALFormsClient
+from contentgrid_hal_client.security import IdentityAuthenticationManager
+from pydantic import HttpUrl
+from contentgrid_extension_helpers.dependencies.authentication.user import ContentGridUserDependency
+from .client_factory import ContentGridBaseClientFactory, ContentGridClientFactorySettings
+
+T = TypeVar('T', ContentGridApplicationClient, HALFormsClient)
+
+oauth2_scheme = create_oauth2_scheme()
+
+class ExtensionFlowConfig(ContentGridClientFactorySettings):
+    extension_client_name: str 
+    extension_client_secret: str
+    system_exchange_uri: str = "https://extensions.sandbox.contentgrid.cloud/authentication/system/token"
+    extension_auth_url: str = "https://auth.sandbox.contentgrid.cloud/realms/extensions/protocol/openid-connect/token"
+    delegated_exchange_uri: str = "https://extensions.sandbox.contentgrid.cloud/authentication/delegated/token"
+
+class ContentGridExtensionFlowClientFactory(ContentGridBaseClientFactory):
+    def __init__(
+        self,
+        extension_auth_url: Optional[str] = None,
+        extension_client_name: Optional[str] = None,
+        extension_client_secret: Optional[str] = None,
+        system_exchange_uri: Optional[str] = None,
+        delegated_exchange_uri: Optional[str] = None,
+    ) -> None:
+        # Create config dict with provided parameters
+        config_dict = {}
+        if extension_auth_url is not None:
+            config_dict['extension_auth_url'] = extension_auth_url
+        if extension_client_name is not None:
+            config_dict['extension_client_name'] = extension_client_name
+        if extension_client_secret is not None:
+            config_dict['extension_client_secret'] = extension_client_secret
+        if system_exchange_uri is not None:
+            config_dict['system_exchange_uri'] = system_exchange_uri
+        if delegated_exchange_uri is not None:
+            config_dict['delegated_exchange_uri'] = delegated_exchange_uri
+            
+        # Create ExtensionFlowConfig instance which will use env vars for missing values
+        self.extension_config = ExtensionFlowConfig(**config_dict)
+
+        self.identity_auth_manager = IdentityAuthenticationManager(
+            auth_uri=self.extension_config.extension_auth_url,
+            client_id=self.extension_config.extension_client_name,
+            client_secret=self.extension_config.extension_client_secret,
+            system_exchange_uri=self.extension_config.system_exchange_uri,
+            delegated_exchange_uri=self.extension_config.delegated_exchange_uri,
+        )
+        super().__init__()
+        
+    @property
+    def config(self) -> ExtensionFlowConfig:
+        return self.extension_config
+        
+    def get_client(self, user: ContentGridUser, origin: Optional[HttpUrl], client_type: Type[T] = ContentGridApplicationClient) -> T:
+        """Get a client of the specified type."""
+        client_endpoint = self._get_client_endpoint(
+            origin=origin,
+            allowed_domains=user.domains
+        )
+        auth_manager = self.identity_auth_manager.for_user(user.access_token, urls={client_endpoint})
+        
+        return client_type(
+            client_endpoint=client_endpoint,
+            auth_manager=auth_manager,
+        )
+        
+    def create_client_dependency(self, user_dependency: ContentGridUserDependency, client_type: Type[T] = ContentGridApplicationClient):
+        """Create a dependency function for the specified client type."""
+        def client_dependency(
+            user: Annotated[ContentGridUser, Depends(user_dependency)], 
+            origin: Annotated[Optional[HttpUrl], Query()] = None
+        ) -> T:
+            return self.get_client(user, origin, client_type)
+
+        return client_dependency

contentgrid_extension_helpers/dependencies/clients/contentgrid/service_account_factory.py

@@ -0,0 +1,87 @@
+from typing import Annotated, Optional, Type, TypeVar, List
+from fastapi import Query
+from contentgrid_application_client.application import ContentGridApplicationClient
+from contentgrid_hal_client.hal import HALFormsClient
+from contentgrid_hal_client.security import ClientCredentialsApplicationAuthenticationManager
+from pydantic import Field, HttpUrl
+from pydantic_settings import SettingsConfigDict
+from .client_factory import ContentGridBaseClientFactory, ContentGridClientFactorySettings
+
+T = TypeVar('T', ContentGridApplicationClient, HALFormsClient)
+
+class ContentGridServiceAccountFactorySettings(ContentGridClientFactorySettings):
+    model_config = SettingsConfigDict(env_prefix='CG_')
+
+    auth_url: str
+    client_name: str
+    client_secret: str
+    # Default endpoint for service account, can be overridden
+    default_endpoint: Optional[str] = Field(default=None, alias='CG_APP_URL')
+    # Allowed domains for service account access
+    allowed_domains: Optional[List[str]] = None
+
+class ContentGridServiceAccountFactory(ContentGridBaseClientFactory):
+    def __init__(
+        self,
+        auth_url: Optional[str] = None,
+        client_name: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        default_endpoint: Optional[str] = None,
+        allowed_domains: Optional[List[str]] = None,
+    ) -> None:
+        # Create config dict with provided parameters
+        config_dict = {}
+        if auth_url is not None:
+            config_dict['auth_url'] = auth_url
+        if client_name is not None:
+            config_dict['client_name'] = client_name
+        if client_secret is not None:
+            config_dict['client_secret'] = client_secret
+        if default_endpoint is not None:
+            config_dict['default_endpoint'] = default_endpoint
+        if allowed_domains is not None:
+            config_dict['allowed_domains'] = allowed_domains
+            
+        # Create ServiceAccountFactorySettings instance which will use env vars for missing values
+        self.service_account_config = ContentGridServiceAccountFactorySettings(**config_dict)
+
+        self.authentication_manager = ClientCredentialsApplicationAuthenticationManager(
+            auth_uri=self.service_account_config.auth_url,
+            client_id=self.service_account_config.client_name,
+            client_secret=self.service_account_config.client_secret,
+        )
+        super().__init__()
+        
+    @property
+    def config(self) -> ContentGridServiceAccountFactorySettings:
+        return self.service_account_config
+        
+    def get_client(self, origin: Optional[HttpUrl] = None, client_type: Type[T] = ContentGridApplicationClient) -> T:
+        """Get a client of the specified type using service account authentication."""
+        client_endpoint = self._get_client_endpoint(
+            origin=origin,
+            allowed_domains=self.service_account_config.allowed_domains,
+            default_endpoint=self.service_account_config.default_endpoint
+        )
+        
+        # Create a new authentication manager instance for this specific endpoint
+        auth_manager = ClientCredentialsApplicationAuthenticationManager(
+            auth_uri=self.service_account_config.auth_url,
+            client_id=self.service_account_config.client_name,
+            client_secret=self.service_account_config.client_secret,
+            resources=[client_endpoint]
+        )
+        
+        return client_type(
+            client_endpoint=client_endpoint,
+            auth_manager=auth_manager,
+        )
+        
+    def create_client_dependency(self, client_type: Type[T] = ContentGridApplicationClient):
+        """Create a dependency function for the specified client type (no user required)."""
+        def client_dependency(
+            origin: Annotated[Optional[HttpUrl], Query()] = None
+        ) -> T:
+            return self.get_client(origin, client_type)
+
+        return client_dependency

contentgrid_extension_helpers/dependencies/sqlalch/db/__init__.py

@@ -0,0 +1,14 @@
+"""Database factory classes for different database backends."""
+
+from .base_factory import DatabaseConfig, DatabaseSessionFactory
+from .sqlite import SQLiteConfig, SQLiteSessionFactory
+from .postgres import PostgresConfig, PostgresSessionFactory
+
+__all__ = [
+    "DatabaseConfig",
+    "DatabaseSessionFactory", 
+    "SQLiteConfig",
+    "SQLiteSessionFactory",
+    "PostgresConfig", 
+    "PostgresSessionFactory"
+]

contentgrid_extension_helpers/dependencies/sqlalch/db/base_factory.py

@@ -0,0 +1,107 @@
+import logging
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from typing import Optional, Dict, Any, Generator
+from sqlmodel import SQLModel, Session, create_engine, text
+from pydantic_settings import BaseSettings
+
+class DatabaseConfig(BaseSettings):
+    debug: bool = False
+
+class DatabaseSessionFactory(ABC):
+    """Abstract factory class to create database connections based on configuration."""
+    
+    def __init__(self, config : Optional[DatabaseConfig] = None):
+        """Initialize with database configuration."""
+        self.db_config = config if config else DatabaseConfig()
+        
+        # Get values from abstract methods and validate them
+        connection_string = self.create_connection_string()
+        connect_args = self.create_connect_args()
+        engine_kwargs = self.create_engine_kwargs()
+        
+        # Assert that required values are provided
+        assert connection_string is not None and connection_string.strip(), "Connection string must be a non-empty string"
+        assert isinstance(connect_args, dict), "Connect args must be a dictionary"
+        assert isinstance(engine_kwargs, dict), "Engine kwargs must be a dictionary"
+        
+        self.engine = create_engine(
+            connection_string,
+            connect_args=connect_args,
+            echo="debug" if self.db_config.debug else None,  # Log SQL queries in debug mode
+            **engine_kwargs
+        )
+    
+    @abstractmethod
+    def create_connection_string(self) -> str:
+        """Create the database connection string."""
+        pass
+    
+    @abstractmethod
+    def create_connect_args(self) -> Dict[str, Any]:
+        """Create connection arguments."""
+        pass
+    
+    @abstractmethod
+    def create_engine_kwargs(self) -> Dict[str, Any]:
+        """Create engine keyword arguments."""
+        pass
+        
+    def create_db_and_tables(self) -> None:
+        """Create database tables from SQLModel metadata."""
+        SQLModel.metadata.create_all(self.engine)
+        
+    # IMPORTANT : NO AUTOCOMMITS
+    # SQLAlchemy session management
+    # This function is used for dependency injection in FastAPI
+    # It provides a session that is NOT automatically committed. 
+    # It is the responsibility of the caller to commit one or more transactions.
+    # When an error occurs the session is rolledback.
+    def __call__(self) -> Generator[Session, None, None]:
+        """Get a database session for dependency injection."""
+        session = Session(self.engine)
+        try:
+            yield session
+        except Exception as e:
+            logging.exception(f"Database session error - Unexpected error: {e}")
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    # Context managers can no be used for dependency injection in FastAPI
+    # but they are useful for manual session management in scripts or tests.
+    @contextmanager
+    def get_db_session(self) -> Generator[Session, None, None]:
+        """Context manager for database sessions."""
+        session = Session(self.engine)
+        try:
+            yield session
+            session.commit()
+        except Exception as e:
+            logging.exception(f"Database transaction error - Unexpected error: {e}")
+            session.rollback()
+            raise
+        finally:
+            session.close()
+    
+    def database_health_check(self) -> bool:
+        """Check if database connection is healthy."""
+        try:
+            with self.get_db_session() as session:
+                # Simple query to test connection
+                session.exec(text("SELECT 1"))
+                return True
+        except Exception as e:
+            logging.exception(f"Database health check failed - Unexpected error: {e}")
+            return False
+        
+    def wipe_database(self) -> None:
+        """Wipes the database by dropping all tables and recreating them."""
+        from sqlmodel import SQLModel
+        try:
+            SQLModel.metadata.drop_all(self.engine)
+            SQLModel.metadata.create_all(self.engine)
+            logging.debug("Database tables dropped and recreated successfully")
+        except Exception as e:
+            logging.warning(f"Database cleanup failed: {e}")

contentgrid_extension_helpers/dependencies/sqlalch/db/postgres.py

@@ -0,0 +1,104 @@
+
+from typing import Optional, Dict, Any
+from .base_factory import DatabaseConfig, DatabaseSessionFactory
+
+class PostgresConfig(DatabaseConfig):
+    pg_host: Optional[str] = None
+    pg_port: Optional[int] = None
+    pg_user: Optional[str] = None
+    pg_passwd: Optional[str] = None
+    pg_dbname: Optional[str] = None
+    
+    # Database Connection Pool Configuration
+    db_pool_size: int = 10
+    db_max_overflow: int = 20
+    db_pool_recycle: int = 3600
+    db_pool_pre_ping: bool = True
+
+# Pydantic settings is used throughout this file.
+# The library allows for easy configuration management, including environment variable loading and validation.
+# Each field can be configured to load from environment variables, and validation can be applied to ensure correct types and formats.
+# Example:
+# class MyConfig(BaseSettings):
+#     my_field: str = "default_value"
+#     my_required_bool: bool  # This field must be provided
+#     my_optional_field: Optional[int] = None
+# 
+# ENVIRONMENT VARIABLES:
+# MY_FIELD=my_value
+# MY_REQUIRED_BOOL=t
+# MY_OPTIONAL_FIELD=42
+# See https://docs.pydantic.dev/latest/api/pydantic_settings/ for more details.
+
+class PostgresSessionFactory(DatabaseSessionFactory):
+    """Factory class to create PostgreSQL database connections."""
+    def __init__(self, pg_host: Optional[str] = None, pg_port: Optional[int] = None,
+                 pg_user: Optional[str] = None, pg_passwd: Optional[str] = None,
+                 pg_dbname: Optional[str] = None, debug: Optional[bool] = None,
+                 db_pool_size: Optional[int] = None, db_max_overflow: Optional[int] = None,
+                 db_pool_recycle: Optional[int] = None, db_pool_pre_ping: Optional[bool] = None):
+        """Initialize with PostgreSQL configuration."""
+        # Create config dict with provided parameters
+        config_dict = {}
+        if debug is not None:
+            config_dict['debug'] = debug
+        if db_pool_size is not None:
+            config_dict['db_pool_size'] = db_pool_size
+        if db_max_overflow is not None:
+            config_dict['db_max_overflow'] = db_max_overflow
+        if db_pool_recycle is not None:
+            config_dict['db_pool_recycle'] = db_pool_recycle
+        if db_pool_pre_ping is not None:
+            config_dict['db_pool_pre_ping'] = db_pool_pre_ping
+            
+        # Override with explicit parameters if provided
+        if pg_host is not None:
+            config_dict['pg_host'] = pg_host
+        if pg_port is not None:
+            config_dict['pg_port'] = pg_port
+        if pg_user is not None:
+            config_dict['pg_user'] = pg_user
+        if pg_passwd is not None:
+            config_dict['pg_passwd'] = pg_passwd
+        if pg_dbname is not None:
+            config_dict['pg_dbname'] = pg_dbname
+            
+        # Create PostgresConfig instance which will use env vars for missing values
+        self.postgres_config = PostgresConfig(**config_dict)
+            
+        # Validate required fields
+        missing_fields = []
+        if not self.postgres_config.pg_host:
+            missing_fields.append("PG_HOST")
+        if not self.postgres_config.pg_port:
+            missing_fields.append("PG_PORT")
+        if not self.postgres_config.pg_user:
+            missing_fields.append("PG_USER")
+        if not self.postgres_config.pg_passwd:
+            missing_fields.append("PG_PASSWD")
+        if not self.postgres_config.pg_dbname:
+            missing_fields.append("PG_DBNAME")
+        
+        if missing_fields:
+            raise ValueError(
+                f"Failed to configure postgres. Missing parameters or environment variables: {', '.join(missing_fields)}"
+            )
+        
+        super().__init__(self.postgres_config)
+    
+    def create_connection_string(self) -> str:
+        """Create the PostgreSQL connection string."""
+        return f"postgresql+psycopg2://{self.postgres_config.pg_user}:{self.postgres_config.pg_passwd}@{self.postgres_config.pg_host}:{self.postgres_config.pg_port}/{self.postgres_config.pg_dbname}"
+    
+    def create_connect_args(self) -> Dict[str, Any]:
+        """Create PostgreSQL connection arguments."""
+        return {}
+    
+    def create_engine_kwargs(self) -> Dict[str, Any]:
+        """Create PostgreSQL engine keyword arguments."""
+        return {
+            "pool_size": self.postgres_config.db_pool_size,
+            "max_overflow": self.postgres_config.db_max_overflow,
+            "pool_pre_ping": self.postgres_config.db_pool_pre_ping,
+            "pool_recycle": self.postgres_config.db_pool_recycle
+        }

contentgrid_extension_helpers/dependencies/sqlalch/db/sqlite.py

@@ -0,0 +1,43 @@
+from typing import Dict, Any, Optional
+
+from pydantic import field_validator
+from .base_factory import DatabaseConfig, DatabaseSessionFactory
+
+
+class SQLiteConfig(DatabaseConfig):
+    sqlite_file_name: str = "database.db"
+
+    @field_validator("sqlite_file_name")
+    def validate_sqlite_file_name(cls, value: str) -> str:
+        if not value.endswith('.db'):
+            raise ValueError("SQLite file name must end with '.db'")
+        return value
+
+
+class SQLiteSessionFactory(DatabaseSessionFactory):
+    """Factory class to create SQLite database connections."""
+    
+    def __init__(self, debug: Optional[bool]= None, sqlite_file_name : Optional[str] = None):
+        config_dict = {}
+        if debug is not None:
+            config_dict['debug'] = debug
+        if sqlite_file_name is not None:
+            config_dict['sqlite_file_name'] = sqlite_file_name
+        
+        db_config = SQLiteConfig(**config_dict)
+        super().__init__(db_config)
+    
+    def create_connection_string(self) -> str:
+        """Create the SQLite connection string."""
+        config = self.db_config
+        if not isinstance(config, SQLiteConfig):
+            raise ValueError("SQLiteConfig is required for SQLiteSessionFactory")
+        return f"sqlite:///{config.sqlite_file_name}"
+    
+    def create_connect_args(self) -> Dict[str, Any]:
+        """Create SQLite connection arguments."""
+        return {"check_same_thread": False}
+    
+    def create_engine_kwargs(self) -> Dict[str, Any]:
+        """Create SQLite engine keyword arguments."""
+        return {}  # No pool config for SQLite

contentgrid_extension_helpers/dependencies/sqlalch/repositories/__init__.py

@@ -0,0 +1 @@
+from .base_repository import BaseRepository

contentgrid_extension_helpers/dependencies/sqlalch/repositories/base_repository.py

@@ -0,0 +1,52 @@
+from typing import Dict, Generic, List, Type, TypeVar
+from contentgrid_hal_client import NotFound
+from sqlmodel import SQLModel, Session, select
+
+
+T = TypeVar('T', bound=SQLModel)
+CreateT = TypeVar('CreateT', bound=SQLModel)
+UpdateT = TypeVar('UpdateT', bound=SQLModel)
+
+class BaseRepository(Generic[T, CreateT, UpdateT]):
+    """Generic base repository for database operations"""
+
+    def __init__(self, session: Session, model_class: Type[T]):
+        self.session = session
+        self.model_class = model_class
+
+    def create(self, create_model: CreateT) -> T:
+        """Create a new entity"""
+        db_entity = self.model_class.model_validate(create_model)
+        self.session.add(db_entity)
+        self.session.commit()
+        self.session.refresh(db_entity)
+        return db_entity
+
+    def get_by_id(self, entity_id: int) -> T:
+        """Get entity by ID"""
+        entity = self.session.get(self.model_class, entity_id)
+        if not entity:
+            raise NotFound(f"{self.model_class.__name__} with id {entity_id} not found")
+        return entity
+
+    def get_all(self, offset: int = 0, limit: int = 100) -> List[T]:
+        # user filter has to be pre query for no error pagination 
+        """Get all entities with pagination"""
+        return self.session.exec(select(self.model_class).offset(offset).limit(limit)).all()
+
+    def update(self, entity_id: int, update_model: UpdateT) -> T:
+        """Update entity by ID"""
+        db_entity = self.get_by_id(entity_id)
+        update_data = update_model.model_dump(exclude_unset=True)
+        db_entity.sqlmodel_update(update_data)
+        self.session.add(db_entity)
+        self.session.commit()
+        self.session.refresh(db_entity)
+        return db_entity
+
+    def delete(self, entity_id: int) -> Dict[str, bool]:
+        """Delete entity by ID"""
+        db_entity = self.get_by_id(entity_id)
+        self.session.delete(db_entity)
+        self.session.commit()
+        return {"ok": True}

contentgrid_extension_helpers/middleware/exception_middleware.py

@@ -13,7 +13,7 @@ from contentgrid_hal_client.exceptions import (
 from requests.exceptions import HTTPError
 from contentgrid_extension_helpers.exceptions import LLMDenyException
 
-async def catch_exceptions_middleware(request: Request, call_next, problem_base_url: str = "https://docs.contentgrid.com"):
+async def catch_exceptions_middleware(request: Request, call_next, problem_base_url: str = "https://problems.contentgrid.test"):
     """
     Catches exceptions and returns ProblemResponse objects.
 

contentgrid_extension_helpers/responses/hal.py

@@ -0,0 +1,218 @@
+from enum import Enum
+from urllib.parse import urlencode
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+from pydantic import BaseModel, Field, field_serializer
+from fastapi._compat import ModelField
+from typing import Dict, Optional, Tuple, Type, Any, Union, List, Self, TypeVar, Generic, Callable, cast
+import logging
+from contentgrid_hal_client.hal import HALShape, HALLink
+from contentgrid_hal_client.hal_forms import HALFormsTemplate, HALFormsMethod, HALFormsPropertyType, HALFormsProperty
+import uri_template
+
+def get_route_from_app(app: FastAPI, endpoint_function: str, tags : Optional[List[str | Enum]] = None) -> APIRoute:
+    for route in app.routes:
+        if isinstance(route, APIRoute) and route.name == endpoint_function:
+            if tags is None:
+                return route
+            else:
+                for tag in route.tags:
+                    if tag in tags:
+                        return route
+    error_message = f"No route found for endpoint {endpoint_function}"
+    raise ValueError(error_message)
+
+def _add_params(url : str, params: Optional[Dict[str, str]] = None) -> str:
+    if params:
+        url_postfix = "?" + urlencode(params)
+        url += url_postfix
+    return url
+
+def get_body_from_route(route : APIRoute) -> Tuple[Optional[BaseModel], dict]:
+    required_body = route.body_field
+    if not required_body:
+        return None, {}
+    pydantic_body, default_data = get_pydantic_base_model_from_model_field(required_body)
+    return pydantic_body, default_data
+    
+def get_pydantic_base_model_from_model_field(model_field : ModelField) -> Tuple[BaseModel, dict]:
+    default_data = model_field._type_adapter.get_default_value() or {}
+    pydantic_body = cast(BaseModel, model_field._type_adapter._type)
+    return pydantic_body, default_data
+
+def extract_hal_forms_properties_from_pydantic_base_model(
+    pydantic_base_model : BaseModel,
+    default_data : dict = {}
+) -> List[HALFormsProperty]:
+    properties : List[HALFormsProperty] = []
+    for field_name, field_info in pydantic_base_model.model_fields.items():
+        # Determine property type based on field type
+        property_type = HALFormsPropertyType.text
+        
+        # Convert field type to HALFormsPropertyType
+        if field_info.annotation is int or field_info.annotation is float:
+            property_type = HALFormsPropertyType.number
+        elif field_info.annotation is bool:
+            property_type = HALFormsPropertyType.checkbox
+        
+        # Get default value for this field if available
+        field_default = default_data.get(field_name) if default_data else None
+        
+        # Create HALFormsProperty
+        field_property = HALFormsProperty(
+            name=field_name,
+            prompt=field_info.description or field_name,
+            required=field_info.is_required(),
+            type=property_type,
+            value=field_default
+        )
+        properties.append(field_property)
+    return properties
+
+class LinkForType(BaseModel):
+    endpoint_function_name: str
+    tags: Optional[List[str | Enum]] = None
+    templated: bool = False
+    path_params: Union[dict[str, str],  Callable[["FastAPIHALResponse"], dict[str, str]]] = Field(default_factory=dict)
+    params: Union[dict[str, Union[str, int, float]], Callable[["FastAPIHALResponse"], dict[str, Union[str, int, float]]]] = Field(default_factory=dict)
+    condition: Union[Callable[["FastAPIHALResponse"], bool], bool] = True
+
+
+class HALLinkFor(LinkForType):
+    pass
+
+class HALTemplateFor(LinkForType):
+    pass
+    
+    
+HALLinks = dict[str, Union[HALLink, HALLinkFor]]
+HALTemplates = dict[str, Union[HALFormsTemplate, HALTemplateFor]]
+
+# Type variable for generic embedded resources - must be a subclass of FastAPIHALResponse
+T = TypeVar('T', bound='FastAPIHALResponse')
+
+
+class FastAPIHALResponse(HALShape):    
+    links: dict[str, Union[HALLink, HALLinkFor]] = Field(alias="_links", exclude=False, default_factory=dict)
+    templates: dict[str, Union[HALFormsTemplate, HALTemplateFor]] | None = Field(default=None, alias="_templates")
+    
+    def __expand_link(self, link : HALLinkFor | HALLink) -> HALLink | None:
+        """
+            Expand the links based on server url and path and params.
+            This method should be called after the class is initialized.
+            Returns None if the link should be excluded based on condition.
+        """
+        if not hasattr(self.__class__, '_app'):
+            raise ValueError("App not initialized. Call init_app() before using this method.")
+        
+        if not isinstance(link, HALLinkFor):
+            return link
+        
+        # Check condition - if False, exclude the link
+        if isinstance(link.condition, bool):
+            if not link.condition:
+                return None
+        elif callable(link.condition):
+            if not link.condition(self):
+                return None
+        
+        if hasattr(self.__class__, '_app') and self.__class__._app:
+            route = get_route_from_app(self.__class__._app, link.endpoint_function_name, tags=link.tags)
+            
+            if hasattr(self.__class__, '_server_url'):
+                uri = f"{self.__class__._server_url}{route.path}"
+            else:
+                uri = route.path
+                
+            expanded_link = HALLink(uri=uri, templated=link.templated)
+            
+            if link.path_params:
+                # Handle callable params
+                if callable(link.path_params):
+                    resolved_path_params = link.path_params(self)
+                else:
+                    resolved_path_params = link.path_params
+                expanded_link.uri = uri_template.URITemplate(expanded_link.uri).expand(**resolved_path_params)
+            
+            if link.params:
+                # Handle callable params
+                if callable(link.params):
+                    resolved_params = link.params(self)
+                else:
+                    resolved_params = link.params
+                expanded_link.uri = _add_params(expanded_link.uri, resolved_params)
+            
+            return expanded_link
+
+    
+    @field_serializer('links')
+    def ser_links(self, value: dict[str, Union[HALLink, HALLinkFor]]) -> dict[str, HALLink]:
+        expanded_links = {}
+        for key, link_value in value.items():
+            expanded_link = self.__expand_link(link_value)
+            if expanded_link is not None:  # Only include if condition is met
+                expanded_links[key] = expanded_link
+        return expanded_links
+    
+    @field_serializer('templates')
+    def ser_templates(self, value: dict[str, Union[HALFormsTemplate, HALTemplateFor]] | None) -> dict[str, HALFormsTemplate]:
+        expanded_templates = {}
+        if value is None:
+            return expanded_templates
+        for key, template_value in value.items():
+            if isinstance(template_value, HALTemplateFor) and hasattr(self.__class__, '_app') and self.__class__._app:
+                try:
+                    hallink = self.__expand_link(HALLinkFor(
+                        **template_value.model_dump()
+                    ))
+                    
+                    if hallink is None:
+                        continue
+                    
+                    uri = hallink.uri
+                    route = get_route_from_app(self.__class__._app, template_value.endpoint_function_name, tags=template_value.tags)
+                    body_model, default_data = get_body_from_route(route=route)
+                    if body_model is None:
+                        properties = []
+                    else:
+                        properties = extract_hal_forms_properties_from_pydantic_base_model(pydantic_base_model=body_model, default_data=default_data)
+                            
+                    #TODO what should we do when there are multiple methods for the same function/endpoint?
+                    expanded_templates[key] = HALFormsTemplate(
+                        title=route.description if hasattr(route, 'description') and route.description else None,
+                        method=HALFormsMethod(list(route.methods)[0]) if hasattr(route, 'methods') and route.methods else HALFormsMethod.GET,
+                        target=uri,
+                        properties=properties
+                    )
+                except ValueError:
+                    logging.error(f"{self.__class__} hal template expansion failed: Route not found for template endpoint: {template_value.endpoint_function_name}")
+                    continue
+            else:
+                expanded_templates[key] = template_value
+        return expanded_templates
+        
+    
+    @classmethod
+    def init_app(cls: Type[Self], app: Any) -> None:
+        """
+        Bind a FastAPI app to other HyperModel base class.
+        This allows HyperModel to convert endpoint function names into
+        working URLs relative to the application root.
+
+        Args:
+            app (FastAPI): Application to generate URLs from
+        """
+        cls._app = app
+        
+    @classmethod
+    def add_server_url(cls: Type[Self], server_url: str) -> None:
+        """
+        Set the server URL for generating absolute URLs.
+
+        Args:
+            server_url (str): The base URL of the server.
+        """
+        cls._server_url = server_url
+        
+class FastAPIHALCollection(FastAPIHALResponse, Generic[T]):
+    embedded: dict[str, List[T]] | None = Field(default=None, alias="_embedded", description="Embedded resources")

{contentgrid_extension_helpers-0.0.2.dist-info → contentgrid_extension_helpers-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: contentgrid-extension-helpers
-Version: 0.0.2
+Version: 0.0.4
 Summary: Helper functions for contentgrid extensions.
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions
@@ -26,7 +26,12 @@ Requires-Dist: requests<3,>=2.20.0
 Requires-Dist: uri-template<2
 Requires-Dist: fastapi>=0.111
 Requires-Dist: PyJWT>2
-Requires-Dist: contentgrid_hal_client>=0.0.10
+Requires-Dist: cryptography>45
+Requires-Dist: contentgrid_hal_client>=0.1
+Requires-Dist: contentgrid_application_client>=0.1
+Requires-Dist: contentgrid_management_client>=0.1
+Requires-Dist: pydantic<3,>=2
+Dynamic: license-file
 
 ### ContentGrid-Extension-Helpers
 

contentgrid_extension_helpers-0.0.4.dist-info/RECORD

@@ -0,0 +1,30 @@
+contentgrid_extension_helpers/__init__.py,sha256=Mw64JI29DW5HOzmL1UA8grdyrOqAQeHlllR_zxjagy8,380
+contentgrid_extension_helpers/config.py,sha256=V6IUE5bRyg0k5Gzbq8YdB2k_0OeEzHOI-_h4gaQJiPQ,1401
+contentgrid_extension_helpers/exceptions.py,sha256=GJOIwDC_51pyhiPaq6wRrkmS3X1aU_PQoEE4sPTgopQ,1812
+contentgrid_extension_helpers/problem_response.py,sha256=v2z_hx92pHWyqMZfnJDi6TaGVIeoGh2AXVr1F9VA00w,1542
+contentgrid_extension_helpers/authentication/__init__.py,sha256=XnupVcladC7H4LudetZ46da9IP69pWKhtRJvikhmIKM,200
+contentgrid_extension_helpers/authentication/oidc.py,sha256=14XEmp_WWDVygb3oBKB9S29UlgJV8wnm_1lw36U4xxc,9820
+contentgrid_extension_helpers/authentication/user.py,sha256=EwUjIczs3oFiM0TQK-eLixVNgeou4OY0zTwszFURmrc,1540
+contentgrid_extension_helpers/dependencies/authentication/user.py,sha256=c3Xgg3J4O_TqfdCIETg0VtNF1NUrzaB-gxCJaojrbv4,2817
+contentgrid_extension_helpers/dependencies/clients/contentgrid/__init__.py,sha256=J43Bq-VOCr3OZQA8QzofQXwhDbB2jI4qEPbSc6JI_oI,240
+contentgrid_extension_helpers/dependencies/clients/contentgrid/client_factory.py,sha256=7WL39-tsHZFve_35drrmwb2NczUxvLMiQQvXsdBguA4,2541
+contentgrid_extension_helpers/dependencies/clients/contentgrid/extension_flow_factory.py,sha256=AHgxq3WttAsW4BqbMrgo77BmX94OMJz_Yb1TrjyWcOs,4111
+contentgrid_extension_helpers/dependencies/clients/contentgrid/service_account_factory.py,sha256=BdUZxK2gU8TFZNWdkufm_73uKAkboyJd08-000kfwLc,3932
+contentgrid_extension_helpers/dependencies/sqlalch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contentgrid_extension_helpers/dependencies/sqlalch/db/__init__.py,sha256=7PntPSCwinwSk2il3_LWoSEHnCmx4bQvYLHPC7WJbDw,414
+contentgrid_extension_helpers/dependencies/sqlalch/db/base_factory.py,sha256=vXFQzot1aR__P1ZyMa7VE_JE1sixJjNkKlZBDppKowE,4263
+contentgrid_extension_helpers/dependencies/sqlalch/db/postgres.py,sha256=X2kWg3EBTNcXhQQxuym4pW0GqmZiLxQFi4tvZqiwl7o,4563
+contentgrid_extension_helpers/dependencies/sqlalch/db/sqlite.py,sha256=2FgAcLs8SqMWCUqlOa-rv_JWGLPVhDVt_eTiwWqWdZA,1592
+contentgrid_extension_helpers/dependencies/sqlalch/repositories/__init__.py,sha256=ApJOGKoqnxLfdCqtnkQoOykPCYMnUQhtX29MyD5nOng,43
+contentgrid_extension_helpers/dependencies/sqlalch/repositories/base_repository.py,sha256=PWN-V_YzYwLxRnZWSIfGyVxi8r9lq3wWObOi0cYcFRg,1975
+contentgrid_extension_helpers/logging/__init__.py,sha256=15tz-g0fLdBjJto8kWcjCYhfXCJg0qrwSXVuXRH9i3Q,77
+contentgrid_extension_helpers/logging/json_logging.py,sha256=NrzoBfEUAwQT7mmCHK0GoFJv5t9rrgjomDTXzZ-vgFI,3112
+contentgrid_extension_helpers/middleware/exception_middleware.py,sha256=6mP7IQ7vPZ6-1_QESnAPZNQ5vA0MTTTzpovdszGp964,4467
+contentgrid_extension_helpers/responses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contentgrid_extension_helpers/responses/hal.py,sha256=MkXzht6sXiRSGaohRiH8-cqKJuOJHmAMpYRz6LcCODQ,9529
+contentgrid_extension_helpers/structured_output/model_deny.py,sha256=n2sEls0kyhvL8hHUKeo3_JQ_ZssyknIbIoDAOUvMVxc,1748
+contentgrid_extension_helpers-0.0.4.dist-info/licenses/LICENSE,sha256=tk6n-p8lEmzLJg-O4052CkMgfUtt1q2Zoh1QLAyL7S8,555
+contentgrid_extension_helpers-0.0.4.dist-info/METADATA,sha256=6b8zCBQwzWNlc1wbrZQCaqtSQJde8KS5M2xJ4pmFAW8,1574
+contentgrid_extension_helpers-0.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+contentgrid_extension_helpers-0.0.4.dist-info/top_level.txt,sha256=yJGGofrNVsl5psVGO0vLFHO1610ob88GtB9zpvS8iIk,30
+contentgrid_extension_helpers-0.0.4.dist-info/RECORD,,

{contentgrid_extension_helpers-0.0.2.dist-info → contentgrid_extension_helpers-0.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.1.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

contentgrid_extension_helpers-0.0.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-contentgrid_extension_helpers/__init__.py,sha256=Mw64JI29DW5HOzmL1UA8grdyrOqAQeHlllR_zxjagy8,380
-contentgrid_extension_helpers/exceptions.py,sha256=GJOIwDC_51pyhiPaq6wRrkmS3X1aU_PQoEE4sPTgopQ,1812
-contentgrid_extension_helpers/problem_response.py,sha256=v2z_hx92pHWyqMZfnJDi6TaGVIeoGh2AXVr1F9VA00w,1542
-contentgrid_extension_helpers/authentication/__init__.py,sha256=XnupVcladC7H4LudetZ46da9IP69pWKhtRJvikhmIKM,200
-contentgrid_extension_helpers/authentication/oidc.py,sha256=14XEmp_WWDVygb3oBKB9S29UlgJV8wnm_1lw36U4xxc,9820
-contentgrid_extension_helpers/authentication/user.py,sha256=pr3DVZKchLxpJXU6k2uUNLquwr9LjWfr_sArdAjUjZU,185
-contentgrid_extension_helpers/logging/__init__.py,sha256=15tz-g0fLdBjJto8kWcjCYhfXCJg0qrwSXVuXRH9i3Q,77
-contentgrid_extension_helpers/logging/json_logging.py,sha256=NrzoBfEUAwQT7mmCHK0GoFJv5t9rrgjomDTXzZ-vgFI,3112
-contentgrid_extension_helpers/middleware/exception_middleware.py,sha256=RXbdTzdtfufrGBfViTIQZw691jgXE3rmogKF28Vlhzs,4462
-contentgrid_extension_helpers/structured_output/model_deny.py,sha256=n2sEls0kyhvL8hHUKeo3_JQ_ZssyknIbIoDAOUvMVxc,1748
-contentgrid_extension_helpers-0.0.2.dist-info/LICENSE,sha256=tk6n-p8lEmzLJg-O4052CkMgfUtt1q2Zoh1QLAyL7S8,555
-contentgrid_extension_helpers-0.0.2.dist-info/METADATA,sha256=VIMjWfLhujv6cT5eJvnUozPrKy1G4yVwo8XsNPpmRGM,1393
-contentgrid_extension_helpers-0.0.2.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-contentgrid_extension_helpers-0.0.2.dist-info/top_level.txt,sha256=yJGGofrNVsl5psVGO0vLFHO1610ob88GtB9zpvS8iIk,30
-contentgrid_extension_helpers-0.0.2.dist-info/RECORD,,