Chiji Bundle Laravel Package

Getting Started

Minimal Setup

1. Installation Add the bundle to your composer.json:

   composer require chigix/chiji-bundle
   

   Enable it in config/bundles.php:

   return [
       // ...
       Chigix\ChijiBundle\ChijiBundle::class => ['all' => true],
   ];
   

2. Configuration Publish the default config:

   php bin/console chiji:install
   

   Update config/packages/chigix_chiji.yaml with your Chiji API credentials:

   chiji:
       api_key: 'your_api_key_here'
       base_uri: 'https://api.chiji.example.com'
   

3. First Use Case Inject the ChijiClient service in a controller or command:

   use Chigix\ChijiBundle\Client\ChijiClient;
   
   class ExampleController extends AbstractController
   {
       public function __construct(private ChijiClient $chiji)
       {}
   
       public function index()
       {
           $response = $this->chiji->get('/v1/data');
           return new JsonResponse($response);
       }
   }
   

Implementation Patterns

Common Workflows

1. API Integration Use the ChijiClient for HTTP requests:

   // GET request
   $data = $this->chiji->get('/endpoint', ['param' => 'value']);
   
   // POST request with payload
   $this->chiji->post('/endpoint', ['key' => 'value']);
   

2. Event-Driven Logic Subscribe to Chiji events via Symfony’s event dispatcher:

   # config/services.yaml
   services:
       App\EventListener\ChijiListener:
           tags:
               - { name: kernel.event_listener, event: chiji.response, method: onResponse }
   

3. Command-Line Automation Create custom commands using the client:

   namespace App\Command;
   
   use Chigix\ChijiBundle\Client\ChijiClient;
   use Symfony\Component\Console\Command\Command;
   use Symfony\Component\Console\Input\InputInterface;
   use Symfony\Component\Console\Output\OutputInterface;
   
   class SyncDataCommand extends Command
   {
       protected static $defaultName = 'app:chiji:sync';
   
       public function __construct(private ChijiClient $chiji)
       {
           parent::__construct();
       }
   
       protected function execute(InputInterface $input, OutputInterface $output): int
       {
           $output->writeln('Syncing data...');
           $this->chiji->post('/sync', ['force' => true]);
           return Command::SUCCESS;
       }
   }
   

4. Twig Integration (if supported) Pass data to templates via controllers or create a custom Twig extension:

   // src/Twig/AppExtension.php
   class AppExtension extends \Twig\Extension\AbstractExtension
   {
       public function getFunctions()
       {
           return [
               new \Twig\TwigFunction('chiji_data', [$this, 'getChijiData']),
           ];
       }
   
       public function getChijiData(ChijiClient $chiji)
       {
           return $chiji->get('/widget/data');
       }
   }
   

Gotchas and Tips

Pitfalls

1. Deprecated Bundle

   • The package is archived (no active maintenance). Validate compatibility with your Symfony version (e.g., Symfony 2.x only).
   • Check for breaking changes if upgrading Symfony (e.g., 2.8 → 3.x).

2. Configuration Overrides

   • The bundle may not support Symfony Flex auto-configuration. Manually verify config/packages/chigix_chiji.yaml exists after installation.

3. API Rate Limits

   • No built-in retry logic for rate limits. Implement middleware or decorate ChijiClient:

     $client->setMiddleware(function (callable $next) {
         try {
             return $next();
         } catch (RateLimitException $e) {
             sleep(10); // Retry after delay
             return $next();
         }
     });
     

4. Event Dispatching

   • Events like chiji.response may not be documented. Inspect the bundle’s EventDispatcher class for available events.

Debugging Tips

• Enable Debug Mode Set debug: true in config/packages/chigix_chiji.yaml to log API requests/responses:

  chiji:
      debug: true
  

• Custom HTTP Client Extend ChijiClient to add logging or metrics:

  class CustomChijiClient extends ChijiClient
  {
      public function __construct(GuzzleClient $client, LoggerInterface $logger)
      {
          parent::__construct($client);
          $this->logger = $logger;
      }
  
      protected function doRequest(string $method, string $uri, array $options = [])
      {
          $this->logger->info("Chiji Request: {$method} {$uri}", $options);
          return parent::doRequest($method, $uri, $options);
      }
  }
  

Extension Points

1. Override Services Replace the default ChijiClient in config/services.yaml:

   services:
       Chigix\ChijiBundle\Client\ChijiClient:
           alias: App\Service\CustomChijiClient
   

2. Add Custom Endpoints Extend the bundle’s ChijiClient to include domain-specific methods:

   class ExtendedChijiClient extends ChijiClient
   {
       public function fetchUserData(int $userId): array
       {
           return $this->get("/users/{$userId}");
       }
   }
   

3. Database Sync Use Doctrine listeners to sync Chiji data with your DB:

   // src/EventListener/ChijiSyncListener.php
   class ChijiSyncListener
   {
       public function onResponse(ChijiResponseEvent $event)
       {
           $data = $event->getData();
           // Save to DB via EntityManager
       }
   }