Seemingly retrievev all user information and bot informaiton from api

Author: mathisarends

notionary/__init__.py

@@ -10,4 +10,4 @@
     "NotionWorkspace",
     "NotionUser",
     "NotionUserManager",
-]
+]

notionary/base_notion_client.py

@@ -93,14 +93,19 @@ async def close(self) -> None:
         self._is_initialized = False
         self.logger.debug("NotionClient closed")
 
-    async def get(self, endpoint: str) -> Optional[Dict[str, Any]]:
+    async def get(
+        self, 
+        endpoint: str, 
+        params: Optional[Dict[str, Any]] = None
+    ) -> Optional[Dict[str, Any]]:
         """
         Sends a GET request to the specified Notion API endpoint.
 
         Args:
             endpoint: The API endpoint (without base URL)
+            params: Query parameters to include in the request
         """
-        return await self._make_request(HttpMethod.GET, endpoint)
+        return await self._make_request(HttpMethod.GET, endpoint, params=params)
 
     async def post(
         self, endpoint: str, data: Optional[Dict[str, Any]] = None
@@ -141,6 +146,7 @@ async def _make_request(
         method: Union[HttpMethod, str],
         endpoint: str,
         data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
     ) -> Optional[Dict[str, Any]]:
         """
         Executes an HTTP request and returns the data or None on error.
@@ -149,6 +155,7 @@ async def _make_request(
             method: HTTP method to use
             endpoint: API endpoint
             data: Request body data (for POST/PATCH)
+            params: Query parameters (for GET requests)
         """
         await self.ensure_initialized()
 
@@ -160,15 +167,21 @@ async def _make_request(
         try:
             self.logger.debug("Sending %s request to %s", method_str.upper(), url)
 
+            request_kwargs = {}
+            
+            # Add query parameters for GET requests
+            if params:
+                request_kwargs["params"] = params
+                
             if (
                 method_str in [HttpMethod.POST.value, HttpMethod.PATCH.value]
                 and data is not None
             ):
-                response: httpx.Response = await getattr(self.client, method_str)(
-                    url, json=data
-                )
-            else:
-                response: httpx.Response = await getattr(self.client, method_str)(url)
+                request_kwargs["json"] = data
+
+            response: httpx.Response = await getattr(self.client, method_str)(
+                url, **request_kwargs
+            )
 
             response.raise_for_status()
             result_data = response.json()
@@ -203,4 +216,4 @@ def _find_token(self) -> Optional[str]:
             self.logger.debug("Found token in environment variable.")
             return token
         self.logger.warning("No Notion API token found in environment variables")
-        return None
+        return None

notionary/user/__init__.py

@@ -1,8 +1,9 @@
-from .notion_user import NotionUser, NotionUserManager
+from .notion_user import NotionUser
+from .notion_user_manager import NotionUserManager
 from .client import NotionUserClient
 
 __all__ = [
     "NotionUser",
-    "NotionUserManager", 
+    "NotionUserManager",
     "NotionUserClient",
-]
+]

notionary/user/client.py

@@ -1,8 +1,9 @@
-from typing import Optional
+from typing import Optional, List
 from notionary.base_notion_client import BaseNotionClient
 from notionary.user.models import (
-    NotionUserResponse,
     NotionBotUserResponse,
+    NotionUserResponse,
+    NotionUsersListResponse,
 )
 from notionary.util import singleton
 
@@ -12,26 +13,20 @@ class NotionUserClient(BaseNotionClient):
     """
     Client for Notion user-specific operations.
     Inherits base HTTP functionality from BaseNotionClient.
-    
+
     Note: The Notion API only supports individual user queries and bot user info.
-    There is NO endpoint to list all workspace users via the standard API.
+    List users endpoint is available but only returns workspace members (no guests).
     """
 
     async def get_user(self, user_id: str) -> Optional[NotionUserResponse]:
         """
         Retrieve a user by their ID.
-        
-        Args:
-            user_id: The ID of the user to retrieve
-            
-        Returns:
-            Optional[NotionUserResponse]: The user object or None if failed
         """
         response = await self.get(f"users/{user_id}")
         if response is None:
             self.logger.error("Failed to fetch user %s - API returned None", user_id)
             return None
-        
+
         try:
             return NotionUserResponse.model_validate(response)
         except Exception as e:
@@ -41,27 +36,78 @@ async def get_user(self, user_id: str) -> Optional[NotionUserResponse]:
     async def get_bot_user(self) -> Optional[NotionBotUserResponse]:
         """
         Retrieve your token's bot user information.
-        
-        Returns:
-            Optional[NotionBotUserResponse]: The bot user object with full details or None if failed
         """
         response = await self.get("users/me")
         if response is None:
             self.logger.error("Failed to fetch bot user - API returned None")
             return None
-        
+
         try:
             return NotionBotUserResponse.model_validate(response)
         except Exception as e:
             self.logger.error("Failed to validate bot user response: %s", e)
             return None
 
+    async def list_users(
+        self, 
+        page_size: int = 100, 
+        start_cursor: Optional[str] = None
+    ) -> Optional[NotionUsersListResponse]:
+        """
+        List all users in the workspace (paginated).
+        
+        Note: Guests are not included in the response.
+        """
+        params = {"page_size": min(page_size, 100)}  # API max is 100
+        if start_cursor:
+            params["start_cursor"] = start_cursor
+            
+        response = await self.get("users", params=params)
+        if response is None:
+            self.logger.error("Failed to fetch users list - API returned None")
+            return None
+
+        try:
+            return NotionUsersListResponse.model_validate(response)
+        except Exception as e:
+            self.logger.error("Failed to validate users list response: %s", e)
+            return None
+
+    async def get_all_users(self) -> List[NotionUserResponse]:
+        """
+        Get all users in the workspace by handling pagination automatically.
+        """
+        all_users = []
+        start_cursor = None
+        
+        while True:
+            try:
+                response = await self.list_users(
+                    page_size=100, 
+                    start_cursor=start_cursor
+                )
+                
+                if not response or not response.results:
+                    break
+                    
+                all_users.extend(response.results)
+                
+                # Check if there are more pages
+                if not response.has_more or not response.next_cursor:
+                    break
+                    
+                start_cursor = response.next_cursor
+                
+            except Exception as e:
+                self.logger.error("Error fetching all users: %s", str(e))
+                break
+        
+        self.logger.info("Retrieved %d total users from workspace", len(all_users))
+        return all_users
+
     async def get_workspace_name(self) -> Optional[str]:
         """
         Get the workspace name from the bot user.
-        
-        Returns:
-            Optional[str]: Workspace name if available
         """
         try:
             bot_user = await self.get_bot_user()
@@ -75,9 +121,6 @@ async def get_workspace_name(self) -> Optional[str]:
     async def get_workspace_limits(self) -> Optional[dict]:
         """
         Get workspace limits from the bot user.
-        
-        Returns:
-            Optional[dict]: Workspace limits if available
         """
         try:
             bot_user = await self.get_bot_user()

notionary/user/models.py

@@ -1,7 +1,7 @@
-from typing import Literal, Optional, Dict, Any, Union
+from dataclasses import dataclass
+from typing import Literal, Optional
 from pydantic import BaseModel
 
-
 class PersonUser(BaseModel):
     """Person user details"""
     email: Optional[str] = None
@@ -49,4 +49,24 @@ class NotionBotUserResponse(NotionUserResponse):
     """
     # Bot users should have these fields, but they can still be None
     type: Literal["bot"]
-    bot: Optional[BotUser] = None
+    bot: Optional[BotUser] = None
+    
+class NotionUsersListResponse(BaseModel):
+    """
+    Response model for paginated users list from /v1/users endpoint.
+    Follows Notion's standard pagination pattern.
+    """
+    
+    object: Literal["list"]
+    results: list[NotionUserResponse]
+    next_cursor: Optional[str] = None
+    has_more: bool
+    type: Literal["user"]
+    user: dict = {} 
+    
+# TODO: This is not used so use it
+@dataclass
+class WorkspaceInfo:
+    """Dataclass to hold workspace information for bot users."""
+    name: Optional[str] = None
+    limits: Optional[WorkspaceLimits] = None