Download the PHP package jjuanrivvera/canvas-lms-kit without Composer

✨ Why Canvas LMS Kit?

• 🚀 Production Ready: Rate limiting, middleware support, battle-tested
• 📚 Comprehensive: 45 Canvas APIs fully implemented
• 🛡️ Type Safe: Full PHP 8.1+ type declarations, strict_types, and PHPStan level 6
• 🔧 Developer Friendly: Intuitive Active Record pattern - just pass arrays!
• 📖 Well Documented: Extensive examples, guides, and API reference
• ⚡ Performance: Built-in pagination, caching support, and optimized queries
• 🎯 Code Quality: PHP-CS-Fixer integration, PSR-12 compliance

🎯 Quick Start

📑 Table of Contents

• Requirements
• Installation
• Configuration
• Usage Examples
• Supported APIs
• Advanced Features
• Testing
• Contributing
• Support

📋 Requirements

• PHP 8.1 or higher
• Composer
• Canvas LMS API token
• Extensions: json, curl, mbstring

📦 Installation

⚙️ Configuration

API Key Authentication (Simple)

OAuth 2.0 Authentication (User-Based) 🆕

Canvas LMS Kit now supports OAuth 2.0 for user-specific authentication with automatic token refresh!

Environment Variable Configuration

Perfect for containerized deployments and 12-factor apps:

Logging Configuration

The SDK supports any PSR-3 compatible logger for comprehensive debugging and monitoring:

Symfony Integration

Advanced Logging Configuration

What Gets Logged:

• ✅ All API requests and responses (with sensitive data sanitization)
• ✅ OAuth token operations (refresh, revoke, exchange)
• ✅ Pagination operations with performance metrics
• ✅ File upload progress (3-step process)
• ✅ Rate limit headers and API costs
• ✅ Error conditions with context

Security: The logging middleware automatically sanitizes sensitive fields like passwords, tokens, and API keys to prevent accidental exposure in logs.

Masquerading (Act As User) 🆕

The SDK supports Canvas's masquerading functionality, allowing administrators to perform API operations on behalf of other users. This is essential for administrative operations, support workflows, and testing.

Global Masquerading

Enable masquerading globally for all subsequent API calls:

Context-Specific Masquerading

In multi-tenant environments, masquerading can be set per context:

Security Considerations

• Permissions Required: The authenticated user must have appropriate Canvas permissions to masquerade
• Error Handling: Canvas will return 401/403 errors if permissions are insufficient
• Audit Trail: Consider logging when masquerading is active for compliance

Common Use Cases

Support Operations:

Testing Permission-Based Features:

Batch Operations for Multiple Users:

📄 Pagination

Canvas LMS Kit provides three simple, consistent methods for handling paginated data across all resources:

The Three Methods

When to Use Each Method

Memory-Safe Processing of Large Datasets

Common Pagination Patterns

Pattern 1: Building a Paginated UI

Pattern 2: Exporting All Data

Pattern 3: Finding Specific Items

PaginationResult Methods

The paginate() method returns a PaginationResult object with helpful methods:

Performance Guidelines

Relationship Methods & Large Datasets

Important: Relationship methods on Course/User/Group instances return ALL pages for completeness:

📖 View Complete Pagination Guide for advanced examples and patterns.

💡 Usage Examples

Working with Courses

Managing Assignments

Working with Modules and Module Items

Working with Current User

Managing Groups

File Uploads

Feature Flags

Conversations (Internal Messaging)

Working with Multi-Context Resources

Some Canvas resources exist in multiple contexts (Account, Course, User, Group). Canvas LMS Kit follows an Account-as-Default convention for consistency:

Multi-Context Resources:

• Rubrics (Account/Course)
• External Tools (Account/Course)
• Calendar Events (Account/Course/User/Group)
• Files (User/Course/Group) - No Account context
• Groups (Account/Course/User)
• Content Migrations (Account/Course/Group/User)

Performance Considerations & Memory Usage

When working with large Canvas instances (universities, enterprise organizations), be mindful of memory usage:

Memory Guidelines:

• Use get() for dashboards and quick views (1 API call)
• Use paginate() for large datasets and UI tables (controlled memory)
• Use all() only when you need complete data AND know it's reasonably sized
• Consider your server's memory limit when using all() on production data

Working with Course-Scoped Resources

Some Canvas resources are strictly course-scoped and require setting the course context before use:

Important Notes:

1. These APIs will throw an exception if you try to use them without setting the course context first.
2. Relationship methods return FIRST PAGE ONLY for performance. To get all items:

Learning Outcomes

Content Migrations

📊 Supported APIs

✅ Currently Implemented (45 APIs)

🚀 Advanced Features

Production-Ready Middleware

Multi-Tenant Support

Pagination Support (Simplified API)

Fluent Interface & Method Chaining

All save() and delete() methods return the instance, enabling method chaining:

Relationship Methods

Raw URL Support (Direct API Calls) 🆕

Make direct API calls to arbitrary Canvas URLs using the Canvas facade class:

Features:

• ✅ Automatic authentication (API key or OAuth)
• ✅ Response parsing (JSON/non-JSON)
• ✅ Security validation (domain allowlisting, HTTPS enforcement)
• ✅ Supports absolute URLs and relative paths
• ✅ All middleware applied (rate limiting, retries, logging)

Context Management (Account-as-Default)

Canvas LMS Kit uses the Account-as-Default convention for multi-context resources:

Why Account-as-Default?

• ✅ Consistency across all multi-context resources
• ✅ Respects Canvas hierarchy (Account → Course → User/Group)
• ✅ Clean separation of concerns
• ✅ No confusion about which context is being used

📖 Full Context Management Guide

🧪 Testing

Code Quality Tools

• PHP-CS-Fixer: Automatically fixes code to comply with PSR-12 standards
• PHPStan: Static analysis at level 6 for maximum type safety
• PHPUnit: Comprehensive test suite with 2,300+ tests
• Strict Types: All files use declare(strict_types=1) for type safety

🤝 Contributing

We welcome contributions! Please see our Contributing Guidelines.

Quick Contribution Guide

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Write tests for your changes
4. Ensure all tests pass (composer check)
5. Commit your changes (git commit -m 'Add amazing feature')
6. Push to the branch (git push origin feature/amazing-feature)
7. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

💬 Support

Resources

• 📚 Wiki Documentation - Comprehensive guides
• 🔍 API Reference - Detailed API docs
• 💬 GitHub Discussions - Community forum
• 📧 Email: [email protected]

⭐ Show Your Support

If you find this project helpful, please consider giving it a star on GitHub! It helps others discover the project and motivates continued development.