Conexteo Notifier Laravel Package

Technical Evaluation

Architecture Fit

• Symfony Notifier Integration: The package bridges Conexteo (a messaging/SMS provider) with Symfony’s Notifier component, enabling seamless SMS/notification delivery via Symfony’s standardized Message and Transport interfaces.

  • Pros: Leverages Symfony’s ecosystem (e.g., Notification classes, Transport abstraction) for consistency with existing email/SMS providers (e.g., Twilio, Mailgun).
  • Cons: Limited to Symfony apps; PHP/Laravel users must use Symfony’s Notifier separately (via symfony/notifier or laravel-notification-channels wrappers).

• Laravel Compatibility:

  • Indirect Fit: Laravel’s native Notification system (via illuminate/notifications) is not directly compatible, but can be adapted via:
    1. Symfony Notifier Bridge: Use symfony/notifier in Laravel (e.g., via spatie/laravel-symfony-notifier).
    2. Custom Channel: Build a Laravel ViaConexteoChannel wrapping this package’s ConexteoTransport.
  • Risk: Adds complexity if Laravel’s native Notification system is already in use.

Integration Feasibility

• Core Features:
  • Supports DSN-based configuration (standard for Symfony Notifier).
  • Likely includes retry logic, failure handling, and async support (inherited from Symfony Notifier).
• Missing:
  • Laravel-specific documentation or examples.
  • Explicit support for Laravel’s Bus queue system or Horizon (if async is needed).
  • Webhook/event listeners for Conexteo-specific features (e.g., delivery reports).

Technical Risk

• High:
  • Symfony Dependency: Requires pulling in Symfony’s Notifier component (~20MB+ dependencies), which may conflict with Laravel’s minimalism or existing Symfony packages.
  • Laravel Gaps: No native Laravel integration means manual bridging (e.g., adapting Notification classes to Symfony’s Message interface).
  • Undocumented: No stars/dependents suggest untested edge cases (e.g., rate limits, character encoding for SMS).
• Mitigation:
  • Test with a sandbox Conexteo DSN before production.
  • Use container binding to abstract Symfony Notifier if Laravel-specific features are critical.

Key Questions

1. Laravel Use Case:
   • Is Symfony Notifier already in use, or is this a greenfield project?
   • Are we replacing an existing SMS provider (e.g., Nexmo, AWS SNS)?
2. Async Requirements:
   • Does Conexteo support webhooks for delivery status? If so, how will Laravel handle them?
3. Cost/Usage:
   • Are there Conexteo-specific limits (e.g., per-second SMS bursts) that require Laravel-side throttling?
4. Fallbacks:
   • What’s the retry/fallback strategy if Conexteo’s API fails?
5. Maintenance:
   • Who owns updates if Conexteo’s API changes? (Package has no maintainer activity.)

Integration Approach

Stack Fit

Migration Path

1. Option A: Symfony Notifier in Laravel (Recommended for New Projects)

   • Install:

     composer require symfony/notifier spatie/laravel-symfony-notifier
     composer require com-company/connexteo-notifier
     

   • Configure in .env:

     CONEXTEO_DSN=conexteo://APP_ID:API_KEY@default?sender=SENDER
     

   • Create a Symfony Notifier Message and send via Laravel:

     use Symfony\Component\Notifier\Message\SmsMessage;
     use Symfony\Component\Notifier\NotifierInterface;
     
     $notifier = app(NotifierInterface::class);
     $message = new SmsMessage('Hello', '+1234567890');
     $notifier->send($message);
     

   • Pros: Clean, leverages Symfony’s battle-tested Notifier.
   • Cons: Adds Symfony dependencies.

2. Option B: Custom Laravel Notification Channel (For Existing Projects)

   • Create a ViaConexteoChannel extending Illuminate\Notifications\Channels\Channel:

     use ComCompany\ConexteoNotifier\Transport\ConexteoTransport;
     
     class ViaConexteoChannel extends Channel {
         public function send($notifiable, ConexteoSms $notification) {
             $transport = new ConexteoTransport(config('services.conexteo.dsn'));
             $message = new SymfonySmsMessage($notification->toSms(), $notifiable->viaConexteoPhone());
             $transport->send($message);
         }
     }
     

   • Register in AppServiceProvider:

     Notification::extend('conexteo', function ($app) {
         return new ViaConexteoChannel();
     });
     

   • Pros: Minimal dependency bloat.
   • Cons: More boilerplate; must handle Symfony-specific quirks.

Compatibility

• Symfony Notifier: Fully compatible (package is a Symfony bundle).
• Laravel:
  • ✅: .env config, service container, and basic notifications.
  • ⚠️: Async queues, webhooks, and failure handling require custom code.
• Conexteo API:
  • Verify support for:
    • Unicode SMS (if sending non-ASCII).
    • Delivery receipts (webhook-based).
    • Rate limits (e.g., 1 SMS/sec without throttling).

Sequencing

1. Phase 1: Proof of Concept
   • Set up a sandbox Conexteo DSN.
   • Send a test SMS via Symfony Notifier in Laravel.
   • Validate delivery and cost.
2. Phase 2: Integration
   • Replace existing SMS logic with conexteo:// DSN.
   • Adapt Laravel Notification classes if using Option B.
3. Phase 3: Observability
   • Log failures and retries (Symfony Notifier includes this by default).
   • Implement webhook handling for delivery status (if needed).
4. Phase 4: Rollout
   • Canary release to a subset of users.
   • Monitor Conexteo’s rate limits and costs.

Operational Impact

Maintenance

• Dependencies:
  • Symfony Notifier: Actively maintained (~100K downloads/month), but adds ~20MB to vendor dir.
  • Conexteo Package: No commits in 6+ months (risk of stale API support).
• Updates:
  • Watch for Symfony Notifier breaking changes (e.g., PHP 8.2+ support).
  • Monitor Conexteo’s API deprecations (package may lag).
• Fallbacks:
  • No built-in fallback to another provider (must implement custom logic).

Support

• Debugging:
  • Symfony Notifier provides logs for failed sends, but Laravel’s native logging may need adjustment.
  • Conexteo-specific errors may require reading Symfony’s TransportException.
• Vendor Lock-in:
  • Migrating away from Conexteo would require rewriting the Transport layer.
• Community:
  • No GitHub issues or discussions (risk of undocumented bugs).

Scaling

• Performance:
  • Symfony Notifier is async-friendly but requires Laravel’s queue system for background processing.
  • Conexteo’s API limits may require:
    • Laravel-side throttling (e.g., throttle middleware).
    • Batch processing for bulk SMS.
• Cost:
  • No built-in cost monitoring; must track SMS volume via Conexteo dashboard or custom logging.
• Horizontal Scaling:
  • Stateless design (DSN-based) works well for multi-server Laravel apps.

Failure Modes