personal-projects/py-wikijs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add caching layer and batch operations for improved performance

Browse Source 
Implement Phase 3 improvements: intelligent caching and batch operations
to significantly enhance SDK performance and usability.

**1. Caching Layer Implementation**

Added complete caching infrastructure with LRU eviction and TTL support:

- `wikijs/cache/base.py`: Abstract BaseCache interface with CacheKey structure
- `wikijs/cache/memory.py`: MemoryCache implementation with:
  * LRU (Least Recently Used) eviction policy
  * Configurable TTL (time-to-live) expiration
  * Cache statistics (hits, misses, hit rate)
  * Resource-specific invalidation
  * Automatic cleanup of expired entries

**Cache Integration:**
- Modified `WikiJSClient` to accept optional `cache` parameter
- Integrated caching into `PagesEndpoint.get()`:
  * Check cache before API request
  * Store successful responses in cache
  * Invalidate cache on write operations (update, delete)

**2. Batch Operations**

Added efficient batch methods to Pages API:

- `create_many(pages_data)`: Batch create multiple pages
- `update_many(updates)`: Batch update pages with partial success handling
- `delete_many(page_ids)`: Batch delete with detailed error reporting

All batch methods include:
- Partial success support (continue on errors)
- Detailed error tracking with indices
- Comprehensive error messages

**3. Comprehensive Testing**

Added 27 new tests (all passing):

- `tests/test_cache.py`: 17 tests for caching (99% coverage)
  * CacheKey string generation
  * TTL expiration
  * LRU eviction policy
  * Cache invalidation (specific & all resources)
  * Statistics tracking

- `tests/endpoints/test_pages_batch.py`: 10 tests for batch operations
  * Successful batch creates/updates/deletes
  * Partial failure handling
  * Empty list edge cases
  * Validation error handling

**Performance Benefits:**
- Caching reduces API calls for frequently accessed pages
- Batch operations reduce network overhead for bulk actions
- Configurable cache size and TTL for optimization

**Example Usage:**

```python
from wikijs import WikiJSClient
from wikijs.cache import MemoryCache

# Enable caching
cache = MemoryCache(ttl=300, max_size=1000)
client = WikiJSClient('https://wiki.example.com', auth='key', cache=cache)

# Cached GET requests
page = client.pages.get(123)  # Fetches from API
page = client.pages.get(123)  # Returns from cache

# Batch operations
pages = client.pages.create_many([
    PageCreate(title="Page 1", path="page-1", content="Content 1"),
    PageCreate(title="Page 2", path="page-2", content="Content 2"),
])

updates = client.pages.update_many([
    {"id": 1, "content": "Updated content"},
    {"id": 2, "is_published": False},
])

result = client.pages.delete_many([1, 2, 3])
print(f"Deleted {result['successful']} pages")
```

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Claude
2025-10-23 14:46:58 +00:00
parent 32853476f0
commit dc0d72c896
7 changed files with 1048 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

299
tests/endpoints/test_pages_batch.py Normal file
View File

@@ -0,0 +1,299 @@
"""Tests for Pages API batch operations."""
import pytest
import responses
from wikijs import WikiJSClient
from wikijs.exceptions import APIError, ValidationError
from wikijs.models import Page, PageCreate, PageUpdate
@pytest.fixture
def client():
"""Create a test client."""
return WikiJSClient("https://wiki.example.com", auth="test-api-key")
class TestPagesCreateMany:
"""Tests for pages.create_many() method."""
@responses.activate
def test_create_many_success(self, client):
"""Test successful batch page creation."""
# Mock API responses for each create
for i in range(1, 4):
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={
"data": {
"pages": {
"create": {
"responseResult": {"succeeded": True},
"page": {
"id": i,
"title": f"Page {i}",
"path": f"page-{i}",
"content": f"Content {i}",
"description": "",
"isPublished": True,
"isPrivate": False,
"tags": [],
"locale": "en",
"authorId": 1,
"authorName": "Admin",
"authorEmail": "admin@example.com",
"editor": "markdown",
"createdAt": "2025-01-01T00:00:00.000Z",
"updatedAt": "2025-01-01T00:00:00.000Z",
},
}
}
}
},
status=200,
)
pages_data = [
PageCreate(title=f"Page {i}", path=f"page-{i}", content=f"Content {i}")
for i in range(1, 4)
]
created_pages = client.pages.create_many(pages_data)
assert len(created_pages) == 3
for i, page in enumerate(created_pages, 1):
assert page.id == i
assert page.title == f"Page {i}"
def test_create_many_empty_list(self, client):
"""Test create_many with empty list."""
result = client.pages.create_many([])
assert result == []
@responses.activate
def test_create_many_partial_failure(self, client):
"""Test create_many with some failures."""
# Mock successful creation for first page
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={
"data": {
"pages": {
"create": {
"responseResult": {"succeeded": True},
"page": {
"id": 1,
"title": "Page 1",
"path": "page-1",
"content": "Content 1",
"description": "",
"isPublished": True,
"isPrivate": False,
"tags": [],
"locale": "en",
"authorId": 1,
"authorName": "Admin",
"authorEmail": "admin@example.com",
"editor": "markdown",
"createdAt": "2025-01-01T00:00:00.000Z",
"updatedAt": "2025-01-01T00:00:00.000Z",
},
}
}
}
},
status=200,
)
# Mock failure for second page
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={"errors": [{"message": "Page already exists"}]},
status=200,
)
pages_data = [
PageCreate(title="Page 1", path="page-1", content="Content 1"),
PageCreate(title="Page 2", path="page-2", content="Content 2"),
]
with pytest.raises(APIError) as exc_info:
client.pages.create_many(pages_data)
assert "Failed to create 1/2 pages" in str(exc_info.value)
assert "Successfully created: 1" in str(exc_info.value)
class TestPagesUpdateMany:
"""Tests for pages.update_many() method."""
@responses.activate
def test_update_many_success(self, client):
"""Test successful batch page updates."""
# Mock API responses for each update
for i in range(1, 4):
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={
"data": {
"updatePage": {
"id": i,
"title": f"Updated Page {i}",
"path": f"page-{i}",
"content": f"Updated Content {i}",
"description": "",
"isPublished": True,
"isPrivate": False,
"tags": [],
"locale": "en",
"authorId": 1,
"authorName": "Admin",
"authorEmail": "admin@example.com",
"editor": "markdown",
"createdAt": "2025-01-01T00:00:00.000Z",
"updatedAt": "2025-01-01T00:10:00.000Z",
}
}
},
status=200,
)
updates = [
{"id": i, "content": f"Updated Content {i}", "title": f"Updated Page {i}"}
for i in range(1, 4)
]
updated_pages = client.pages.update_many(updates)
assert len(updated_pages) == 3
for i, page in enumerate(updated_pages, 1):
assert page.id == i
assert page.title == f"Updated Page {i}"
assert page.content == f"Updated Content {i}"
def test_update_many_empty_list(self, client):
"""Test update_many with empty list."""
result = client.pages.update_many([])
assert result == []
def test_update_many_missing_id(self, client):
"""Test update_many with missing id field."""
updates = [{"content": "New content"}] # Missing 'id'
with pytest.raises(APIError) as exc_info:
client.pages.update_many(updates)
assert "must have an 'id' field" in str(exc_info.value)
@responses.activate
def test_update_many_partial_failure(self, client):
"""Test update_many with some failures."""
# Mock successful update for first page
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={
"data": {
"updatePage": {
"id": 1,
"title": "Updated Page 1",
"path": "page-1",
"content": "Updated Content 1",
"description": "",
"isPublished": True,
"isPrivate": False,
"tags": [],
"locale": "en",
"authorId": 1,
"authorName": "Admin",
"authorEmail": "admin@example.com",
"editor": "markdown",
"createdAt": "2025-01-01T00:00:00.000Z",
"updatedAt": "2025-01-01T00:10:00.000Z",
}
}
},
status=200,
)
# Mock failure for second page
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={"errors": [{"message": "Page not found"}]},
status=200,
)
updates = [
{"id": 1, "content": "Updated Content 1"},
{"id": 999, "content": "Updated Content 999"},
]
with pytest.raises(APIError) as exc_info:
client.pages.update_many(updates)
assert "Failed to update 1/2 pages" in str(exc_info.value)
class TestPagesDeleteMany:
"""Tests for pages.delete_many() method."""
@responses.activate
def test_delete_many_success(self, client):
"""Test successful batch page deletions."""
# Mock API responses for each delete
for i in range(1, 4):
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={"data": {"deletePage": {"success": True}}},
status=200,
)
result = client.pages.delete_many([1, 2, 3])
assert result["successful"] == 3
assert result["failed"] == 0
assert result["errors"] == []
def test_delete_many_empty_list(self, client):
"""Test delete_many with empty list."""
result = client.pages.delete_many([])
assert result["successful"] == 0
assert result["failed"] == 0
assert result["errors"] == []
@responses.activate
def test_delete_many_partial_failure(self, client):
"""Test delete_many with some failures."""
# Mock successful deletion for first two pages
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={"data": {"deletePage": {"success": True}}},
status=200,
)
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={"data": {"deletePage": {"success": True}}},
status=200,
)
# Mock failure for third page
responses.add(
responses.POST,
"https://wiki.example.com/graphql",
json={"errors": [{"message": "Page not found"}]},
status=200,
)
with pytest.raises(APIError) as exc_info:
client.pages.delete_many([1, 2, 999])
assert "Failed to delete 1/3 pages" in str(exc_info.value)
assert "Successfully deleted: 2" in str(exc_info.value)