Chullo Laravel Package

Technical Evaluation

Architecture Fit

• Fedora 4 Integration: Chullo is a dedicated PHP client for Fedora 4, leveraging Guzzle (HTTP client) and EasyRDF (RDF/Linked Data handling). This aligns well with Laravel-based systems requiring semantic web interactions (e.g., digital repositories, linked data applications).
• Laravel Compatibility: While not a Laravel-specific package, Chullo’s dependency on Guzzle (widely used in Laravel) and PSR-compliant design ensure smooth integration. The EasyRDF dependency may require additional Laravel service container configuration.
• Domain-Specific Use Cases: Ideal for digital asset management (DAM), archival systems, or research data platforms where Fedora 4 is the backend. Less relevant for generic CRUD applications.

Integration Feasibility

• HTTP Client Abstraction: Chullo abstracts Fedora 4’s REST API, simplifying interactions (e.g., resource creation, RDF graph manipulation). This reduces boilerplate for Laravel HTTP clients (e.g., Http::post()).
• RDF/Linked Data Support: EasyRDF enables triple-store operations, which can be mapped to Laravel’s Eloquent models or custom repositories for domain-specific logic.
• Transaction Handling: Supports Fedora 4 transactions (/fcr:tx), useful for atomic operations in Laravel’s database transactions.

Technical Risk

• EasyRDF Dependency: EasyRDF is not a Laravel-first library, requiring:
  • Service Provider Registration: To bind EasyRDF’s Graph class to Laravel’s container.
  • Namespace Conflicts: Potential clashes with Laravel’s RDF or GraphQL packages (if used).
• PHP Version Lock: Requires PHP 7.4+, which may necessitate Laravel 8+ (or manual polyfills for older versions).
• Fedora 4-Specific Logic: Assumes Fedora 4’s API structure; migration to other triple stores (e.g., GraphDB) would require refactoring.
• Testing Overhead: Limited Laravel-specific tests; custom integration tests needed for edge cases (e.g., large RDF graphs).

Key Questions

1. How will EasyRDF integrate with Laravel’s service container?
   • Will you use a custom facade or bind the Graph class directly?
   • Example:

     $this->app->bind('easyrdf.graph', function () {
         return new \EasyRdf\Graph();
     });
     

2. What’s the error-handling strategy for Fedora 4 API failures?
   • Will you wrap Chullo calls in Laravel’s try-catch or use custom exceptions?
3. How will you handle RDF data persistence?
   • Will you serialize graphs to JSON/arrays for Laravel models, or use native RDF storage?
4. What’s the rollback plan if Fedora 4 transactions fail?
   • Will Laravel’s database transactions sync with Fedora’s /fcr:tx?
5. Performance implications for large RDF graphs?
   • Chullo streams GET requests (since v2.0.2), but POST/PUT operations with large payloads may need optimization.

Integration Approach

Stack Fit

• Laravel + Chullo + Fedora 4:
  • Frontend: Laravel (API routes, Blade templates, or Inertia.js).
  • Middleware: Chullo handles Fedora 4 HTTP/RDF logic; Laravel manages authentication, validation, and business rules.
  • Database: Fedora 4 (triple store); Laravel’s MySQL/PostgreSQL for metadata or user sessions.
• Alternatives Considered:
  • Direct Guzzle Usage: Possible, but Chullo’s RDF abstractions save development time.
  • Fedora PHP SDK: If available, compare Chullo’s feature parity (e.g., transaction support).

Migration Path

1. Phase 1: Proof of Concept
   • Install Chullo via Composer:

     composer require islandora/chullo
     

   • Test basic operations (e.g., createResource(), saveGraph()) in a Laravel Tinker or Artisan command.
2. Phase 2: Service Layer Integration
   • Create a Laravel service class to wrap Chullo:

     namespace App\Services;
     
     use Islandora\Chullo\Chullo;
     
     class FedoraService {
         protected $chullo;
     
         public function __construct() {
             $this->chullo = Chullo::create(config('fedora.url'));
         }
     
         public function createDigitalObject() {
             $uri = $this->chullo->createResource();
             // ... further logic
             return $uri;
         }
     }
     

   • Register the service in AppServiceProvider:

     $this->app->singleton(FedoraService::class, function ($app) {
         return new FedoraService();
     });
     

3. Phase 3: API/Controller Integration
   • Expose Fedora operations via Laravel API routes:

     Route::post('/digital-objects', [DigitalObjectController::class, 'store']);
     

   • Use Form Requests for validation:

     public function store(StoreDigitalObjectRequest $request, FedoraService $fedora) {
         $uri = $fedora->createDigitalObject($request->validated());
         return response()->json(['uri' => $uri]);
     }
     

4. Phase 4: RDF Data Mapping
   • Decide on RDF ↔ Laravel model mapping:
     • Option A: Serialize RDF to JSON and store in Laravel DB.
     • Option B: Use Laravel’s Eloquent events to sync with Fedora.
   • Example (Option A):

     $graph = $this->chullo->getGraph($uri);
     $data = $graph->serialise('json-ld');
     DigitalObject::create(json_decode($data, true));
     

Compatibility

• Laravel Versions: Tested with PHP 7.4+; Laravel 8+ recommended.
• Fedora 4 Compatibility: Chullo aligns with Fedora API Spec, but version mismatches (e.g., Fedora 4.7+) may require updates.
• Dependency Conflicts:
  • Guzzle: Laravel uses Guzzle; ensure version alignment (Chullo requires ^6.5.8).
  • EasyRDF: No known conflicts, but namespace collisions possible if other RDF libraries are used.

Sequencing

1. Prerequisites:
   • Set up a Fedora 4 instance (e.g., via Docker: docker-compose up from Islandora’s playbook).
   • Configure Laravel’s .env:

     FEDORA_URL=http://localhost:8080/fcrepo/rest
     

2. Core Integration:
   • Implement CRUD operations (create, read, update, delete).
   • Add error handling (e.g., 404 Not Found, 409 Conflict).
3. Advanced Features:
   • Transactions: Use /fcr:tx for atomic operations.
   • RDF Queries: Leverage EasyRDF’s sparql() for complex queries.
4. Testing:
   • Write Pest/PHPUnit tests for:
     • Chullo service methods.
     • API endpoints.
     • Edge cases (e.g., malformed RDF).

Operational Impact

Maintenance

• Dependency Updates:
  • Monitor Guzzle/EasyRDF for breaking changes (e.g., Guzzle 7+).
  • Chullo’s MIT license allows forks if upstream stalls.
• Logging:
  • Log Fedora API responses/errors via Laravel’s Log facade:

    \Log::debug('Fedora response', ['data' => $response->getBody()]);
    

• Backward Compatibility:
  • Chullo’s semver compliance (e.g., ^1.0) simplifies upgrades, but API changes in Fedora 4 may require adjustments.

Support

• Community:
  • Islandora’s Google Groups (link) for Fedora/Chullo issues.
  • Limited Laravel-specific support; self-service debugging likely.
• Debugging Tools:
  • Use Laravel Debugbar to inspect Chullo requests/responses.
  • Enable Guzzle middleware for request logging:

    $client = new \GuzzleHttp\Client([
        'handler' => \GuzzleHttp\HandlerStack::create([
            new \GuzzleHttp\Middleware::tap(function ($request, $