gl-connectors-cli 0.1.0__py3-none-any.whl

gl_connectors_cli/__init__.py

@@ -0,0 +1,5 @@
+"""GL Connectors CLI module for managing integrations and authentication."""
+
+from gl_connectors_cli.main import main
+
+__all__ = ["main"]

gl_connectors_cli/__main__.py

@@ -0,0 +1,12 @@
+"""CLI entry point.
+
+Authors:
+    GL Connectors Team
+"""
+
+import sys
+
+from gl_connectors_cli.main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

gl_connectors_cli/api/__init__.py

@@ -0,0 +1,19 @@
+"""GL Connectors CLI API clients.
+
+Author:
+    I Gusti Ngurah Gana Untaran (i.gusti.n.g.untaran@gdplabs.id)
+"""
+
+from gl_connectors_cli.api.auth import AuthAPIClient
+from gl_connectors_cli.api.integrations import IntegrationsAPIClient
+from gl_connectors_cli.api.models import IntegrationDetail, Token, User
+from gl_connectors_cli.api.users import UsersAPIClient
+
+__all__ = [
+    "AuthAPIClient",
+    "UsersAPIClient",
+    "IntegrationsAPIClient",
+    "User",
+    "Token",
+    "IntegrationDetail",
+]

gl_connectors_cli/api/auth.py

@@ -0,0 +1,47 @@
+"""Authentication API client for GL Connectors CLI.
+
+Author:
+    I Gusti Ngurah Gana Untaran (i.gusti.n.g.untaran@gdplabs.id)
+"""
+
+from gl_connectors_cli.api.base import BaseAPIClient
+from gl_connectors_cli.api.models import Token
+from gl_connectors_cli.constants import API_KEY_HEADER, HTTP_POST
+from gl_connectors_cli.utils import CLIError
+
+
+class AuthAPIClient(BaseAPIClient):
+    """Authentication API client."""
+
+    def authenticate_user(self, client_key: str, identifier: str, secret: str) -> Token:
+        """Authenticate user and get JWT token.
+
+        Args:
+            client_key: Client API key
+            identifier: User identifier
+            secret: User secret
+
+        Returns:
+            Authentication token information
+
+        Raises:
+            CLIError: If authentication fails
+
+        """
+        headers = {
+            API_KEY_HEADER: client_key,
+        }
+
+        data = {"identifier": identifier, "secret": secret}
+
+        try:
+            response = self._make_request(HTTP_POST, "/clients/oauth-token", headers=headers, data=data)
+            token_data = response.get("data", None)
+
+            if not token_data:
+                raise CLIError("Authentication error. Please check your credentials and try again.")
+
+            return Token(**token_data)
+
+        except Exception as e:
+            raise CLIError(str(e)) from e

gl_connectors_cli/api/base.py

@@ -0,0 +1,86 @@
+"""Base API client for GL Connectors CLI.
+
+Author:
+    I Gusti Ngurah Gana Untaran (i.gusti.n.g.untaran@gdplabs.id)
+"""
+
+import json
+from typing import Any, Dict, Optional
+
+import requests
+
+from gl_connectors_cli.constants import HTTP_DELETE, HTTP_GET, HTTP_POST, HTTP_PUT
+from gl_connectors_cli.utils import CLIError
+
+
+class BaseAPIClient:
+    """Base API client with shared request functionality."""
+
+    def __init__(self, base_url: str):
+        """Initialize base API client.
+
+        Args:
+            base_url: Connector base URL
+
+        """
+        self.base_url = base_url.rstrip("/")
+        self.session = requests.Session()
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        headers: Optional[Dict[str, str]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """Make HTTP request to Connector.
+
+        Args:
+            method: HTTP method (GET, POST, DELETE, etc.)
+            endpoint: API endpoint path
+            headers: Request headers
+            data: Request body data
+            params: URL parameters
+
+        Returns:
+            Response JSON data
+
+        Raises:
+            CLIError: If request fails
+
+        """
+        url = f"{self.base_url}{endpoint}"
+
+        try:
+            if method.upper() == HTTP_GET:
+                response = self.session.get(url, headers=headers, params=params)
+            elif method.upper() == HTTP_POST:
+                response = self.session.post(url, headers=headers, json=data, params=params)
+            elif method.upper() == HTTP_DELETE:
+                response = self.session.delete(url, headers=headers, params=params)
+            elif method.upper() == HTTP_PUT:
+                response = self.session.put(url, headers=headers, json=data, params=params)
+            else:
+                raise CLIError(f"Unsupported HTTP method: {method}")
+
+            response_data = response.json()
+            if not response.ok or ("success" in response_data and response_data["success"] is False):
+                error_data = response_data.get("error", {})
+                error_message = error_data.get("message", response.status_code)
+                raise CLIError(f"API error: {error_message}")
+
+            return response_data
+
+        except requests.exceptions.ConnectionError as e:
+            raise CLIError(f"Failed to connect to {self.base_url}: {str(e)}") from e
+        except requests.exceptions.Timeout as e:
+            raise CLIError(f"Request timeout: {str(e)}") from e
+        except requests.exceptions.RequestException as e:
+            raise CLIError(f"Request failed: {str(e)}") from e
+        except json.JSONDecodeError as e:
+            raise CLIError(f"Invalid JSON response from server: {str(e)}") from e
+        except CLIError as e:
+            raise e
+        except Exception as e:
+            raise CLIError(f"An unexpected error occurred: {str(e)}") from e

gl_connectors_cli/api/integrations.py

@@ -0,0 +1,199 @@
+"""Integrations API client for GL Connectors CLI.
+
+Author:
+    I Gusti Ngurah Gana Untaran (i.gusti.n.g.untaran@gdplabs.id)
+"""
+
+from typing import Any, Dict, List
+
+from gl_connectors_cli.api.base import BaseAPIClient
+from gl_connectors_cli.api.models import IntegrationDetail
+from gl_connectors_cli.constants import (
+    API_KEY_HEADER,
+    AUTHORIZATION_HEADER,
+    BEARER_PREFIX,
+    HTTP_DELETE,
+    HTTP_GET,
+    HTTP_POST,
+)
+from gl_connectors_cli.utils import CLIError
+
+
+class IntegrationsAPIClient(BaseAPIClient):
+    """Integrations API client."""
+
+    def get_connectors(self, client_key: str) -> List[str]:
+        """Get all available connectors.
+
+        Args:
+            client_key: Client API key
+
+        Returns:
+            List of available connectors
+
+        Raises:
+            CLIError: If request fails
+
+        """
+        headers = {AUTHORIZATION_HEADER: f"{BEARER_PREFIX} {client_key}"}
+
+        try:
+            response = self._make_request(HTTP_GET, "/connectors", headers=headers)
+
+            return list(response.keys())
+
+        except Exception as e:
+            raise CLIError(f"Failed to get connectors: {str(e)}") from e
+
+    def check_integration_status(self, client_key: str, connector_name: str, token: str) -> bool:
+        """Check if integration exists for a connector.
+
+        Args:
+            client_key: Client API key
+            connector_name: Name of the connector
+            token: User JWT token
+
+        Returns:
+            Integration status information (True if integration exists, False otherwise)
+
+        Raises:
+            CLIError: If request fails
+
+        """
+        headers = {API_KEY_HEADER: client_key, AUTHORIZATION_HEADER: f"{BEARER_PREFIX} {token}"}
+
+        try:
+            response = self._make_request(HTTP_GET, f"/connectors/{connector_name}/integration-exists", headers=headers)
+            return response.get("data", {}).get("has_integration", False)
+
+        except Exception as e:
+            raise CLIError(f"Failed to check integration status: {str(e)}") from e
+
+    def initiate_integration(self, client_key: str, connector_name: str, token: str) -> str:
+        """Initiate OAuth integration for a connector.
+
+        Args:
+            client_key: Client API key
+            connector_name: Name of the connector
+            token: User JWT token
+
+        Returns:
+            str: Integration initiation response (contains OAuth URL)
+
+        Raises:
+            CLIError: If request fails
+
+        """
+        headers = {
+            API_KEY_HEADER: client_key,
+            AUTHORIZATION_HEADER: f"{BEARER_PREFIX} {token}",
+        }
+
+        callback_url = f"{self.base_url}/connectors/{connector_name}/success-authorize-callback"
+
+        data = {"callback_url": callback_url}
+
+        try:
+            response = self._make_request(
+                HTTP_POST, f"/connectors/{connector_name}/integrations", headers=headers, data=data
+            )
+
+            if not response.get("data", {}).get("url"):
+                raise CLIError("Failed to initiate integration.")
+
+            return response.get("data", {}).get("url", "")
+
+        except Exception as e:
+            raise CLIError(f"Failed to initiate integration: {str(e)}") from e
+
+    def remove_integration(
+        self, client_key: str, connector_name: str, user_identifier: str, token: str
+    ) -> Dict[str, Any]:
+        """Remove integration for a connector and specific user identifier.
+
+        Args:
+            client_key: Client API key
+            connector_name: Name of the connector
+            user_identifier: User identifier to specify which integration to remove
+            token: User JWT token
+
+        Returns:
+            Removal response
+
+        Raises:
+            CLIError: If request fails
+
+        """
+        headers = {API_KEY_HEADER: client_key, AUTHORIZATION_HEADER: f"{BEARER_PREFIX} {token}"}
+
+        try:
+            response = self._make_request(
+                HTTP_DELETE, f"/connectors/{connector_name}/integrations/{user_identifier}", headers=headers
+            )
+            return response.get("data", {})
+
+        except Exception as e:
+            raise CLIError(f"Failed to remove integration: {str(e)}") from e
+
+    def get_integration_details_by_identifier(
+        self, client_key: str, connector: str, user_identifier: str, token: str
+    ) -> IntegrationDetail:
+        """Get a specific integration by user identifier.
+
+        Args:
+            client_key: Client API key
+            connector: Connector name
+            user_identifier: The third-party service user identifier (e.g., GitHub username, Google email)
+            token: User token
+
+        Returns:
+            Integration details including access token
+
+        Raises:
+            CLIError: If request fails or integration not found
+
+        """
+        headers = {API_KEY_HEADER: client_key, AUTHORIZATION_HEADER: f"{BEARER_PREFIX} {token}"}
+
+        try:
+            response = self._make_request(
+                HTTP_GET, f"/connectors/{connector}/integrations/{user_identifier}", headers=headers
+            )
+            data = response.get("data", {})
+            if data.get("success") is False:
+                raise CLIError({data.get("error", "Unknown error")})
+
+            return IntegrationDetail(**response.get("data", {}))
+
+        except Exception as e:
+            raise CLIError(f"Failed to get integration for {user_identifier} in {connector}: {str(e)}") from e
+
+    def set_selected_integration(
+        self, client_key: str, connector_name: str, user_identifier: str, token: str
+    ) -> Dict[str, Any]:
+        """Set integration as selected/unselected.
+
+        Args:
+            client_key: Client API key
+            connector_name: Name of the connector
+            user_identifier: User identifier for the integration
+            token: User JWT token
+
+        Returns:
+            Update response
+
+        Raises:
+            CLIError: If request fails
+
+        """
+        headers = {API_KEY_HEADER: client_key, AUTHORIZATION_HEADER: f"{BEARER_PREFIX} {token}"}
+        data = {"selected": True}
+
+        try:
+            response = self._make_request(
+                HTTP_POST, f"/connectors/{connector_name}/integrations/{user_identifier}", headers=headers, data=data
+            )
+            return response.get("data", {})
+
+        except Exception as e:
+            raise CLIError(f"Failed to update integration selection: {str(e)}") from e

gl_connectors_cli/api/models.py

@@ -0,0 +1,47 @@
+"""Shared data models for GL Connectors CLI API clients.
+
+Author:
+    I Gusti Ngurah Gana Untaran (i.gusti.n.g.untaran@gdplabs.id)
+"""
+
+from datetime import datetime
+from typing import Any, Dict, List
+
+from pydantic import BaseModel, Field
+
+
+class User(BaseModel):
+    """GL Connectors user information."""
+
+    id: str
+    identifier: str = ""
+    secret_preview: str = ""
+    is_active: bool = True
+    client_id: str = ""
+    integrations: List[Dict[str, Any]] = Field(default_factory=list)
+
+
+class CreatedUser(User):
+    """GL Connectors user information with secret."""
+
+    secret: str = ""
+
+
+class Token(BaseModel):
+    """GL Connectors authentication token."""
+
+    token: str
+    token_type: str = "Bearer"
+    expires_at: datetime = Field(default_factory=datetime.now)
+    is_revoked: bool = False
+    user_id: str = ""
+
+
+class IntegrationDetail(BaseModel):
+    """Integration detail."""
+
+    connector: str
+    user_identifier: str
+    auth_string: str
+    auth_scopes: List[str]
+    selected: bool = False

gl_connectors_cli/api/users.py

@@ -0,0 +1,66 @@
+"""Users API client for GL Connectors CLI.
+
+Author:
+    I Gusti Ngurah Gana Untaran (i.gusti.n.g.untaran@gdplabs.id)
+"""
+
+from gl_connectors_cli.api.base import BaseAPIClient
+from gl_connectors_cli.api.models import CreatedUser, User
+from gl_connectors_cli.constants import API_KEY_HEADER, AUTHORIZATION_HEADER, BEARER_PREFIX, HTTP_GET, HTTP_POST
+from gl_connectors_cli.utils import CLIError
+
+
+class UsersAPIClient(BaseAPIClient):
+    """Users API client."""
+
+    def create_user(self, client_key: str, username: str) -> CreatedUser:
+        """Create a new user.
+
+        Args:
+            client_key: Client API key
+            username: Username for the new user
+
+        Returns:
+            CreatedUser: User creation response data
+
+        Raises:
+            CLIError: If user creation fails
+
+        """
+        headers = {
+            API_KEY_HEADER: client_key,
+        }
+
+        data = {"identifier": username}
+
+        try:
+            response = self._make_request(HTTP_POST, "/clients/register-user", headers=headers, data=data)
+            user_data = response.get("data", {})
+            return CreatedUser(**user_data)
+
+        except Exception as e:
+            raise CLIError(f"Failed to create user: {str(e)}") from e
+
+    def get_user_info(self, client_key: str, token: str) -> User:
+        """Get current user information.
+
+        Args:
+            client_key: Client API key
+            token: User JWT token
+
+        Returns:
+            User: User information
+
+        Raises:
+            CLIError: If request fails
+
+        """
+        headers = {AUTHORIZATION_HEADER: f"{BEARER_PREFIX} {token}", API_KEY_HEADER: client_key}
+
+        try:
+            response = self._make_request(HTTP_GET, "/clients/user", headers=headers)
+            user_data = response.get("data", {})
+            return User(**user_data)
+
+        except Exception as e:
+            raise CLIError(f"Failed to get user info: {str(e)}") from e

gl_connectors_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands module."""