Yandex Market Orders Laravel Package

Technical Evaluation

Architecture Fit

• Microservice vs. Monolith Fit: The package is designed for Laravel-based e-commerce systems (likely monolithic or modular PHP apps) with tight integration into Yandex Marketplace (FBS/DBS) workflows. If the product is a B2C e-commerce platform (e.g., marketplace aggregator, multi-vendor store, or direct Yandex Market seller), this package aligns well. For B2B, SaaS, or non-e-commerce Laravel apps, the fit is low-to-moderate unless Yandex Market is a core feature.
• Domain Alignment: Strong alignment with order management, payment processing (Yandex.Kassa), and delivery integration for Yandex Marketplace sellers. Assumes existing user profiles, payment gateways, and delivery modules in the Laravel app.
• Extensibility: The package appears to be modular (separate commands for profile types, payments, delivery) but lacks clear hook/observer patterns for custom business logic. May require event listeners or service overrides for deep customization.

Integration Feasibility

• Dependencies:
  • Hard Dependencies:
    • baks-dev/yandex-market (core Yandex Market integration).
    • Laravel 10.x+ (implied by PHP 8.4+).
    • Doctrine ORM (for migrations).
    • Symfony Console (for CLI commands).
  • Soft Dependencies:
    • Yandex.Kassa API (for payments).
    • Yandex Marketplace API (undocumented but implied).
  • Risk: Tight coupling with baks-dev/yandex-market could complicate vendor lock-in or future upgrades.
• Database Schema:
  • Requires custom migrations (Doctrine-based) for order, payment, and delivery tables. Schema conflicts are likely if the app already has order/payment models.
  • Recommendation: Audit existing DB schema early to plan for merge strategies (e.g., extending existing tables vs. parallel schemas).
• API/External Services:
  • Assumes Yandex Marketplace API access (FBS/DBS). Requires API credentials (OAuth, tokens) stored securely (likely in Laravel config or env).
  • Payment Processing: Integrates with Yandex.Kassa; may need webhook handling for async payment confirmations.

Technical Risk

Key Questions

1. Business Context:
   • Is Yandex Market a core sales channel or a pilot feature? This dictates integration priority.
   • Are there existing order/payment/delivery systems that need to coexist or be replaced?
2. Technical Context:
   • What’s the current Laravel version and PHP version? (Package requires PHP 8.4+.)
   • Does the app use Doctrine ORM or another DB layer? If not, migrations may need adaptation.
   • Are there existing payment/delivery integrations that could conflict?
3. Operational Context:
   • Who manages Yandex Marketplace API credentials (tokens, OAuth)?
   • What’s the failure mode tolerance for Yandex API outages?
4. Customization Needs:
   • Are there unique order workflows (e.g., partial refunds, custom delivery rules) not supported by the package?
   • Does the app need multi-marketplace support (e.g., Yandex + other platforms)?

Integration Approach

Stack Fit

• Laravel Compatibility:
  • Core Fit: Designed for Laravel 10.x+ with Symfony components. Assumes Laravel’s service container, migrations, and console.
  • Non-Laravel: Not applicable; hard dependency on Laravel.
• Tech Stack Synergy:
  • Pros:
    • Leverages Laravel’s Eloquent (if using Doctrine) or Doctrine ORM for DB.
    • Uses Symfony Console for CLI-driven setup (aligns with Laravel’s artisan).
    • MIT license allows easy embedding.
  • Cons:
    • No API-first design: Package is CLI/migration-heavy, not REST/GraphQL-ready. Poor fit for headless or API-driven apps.
    • Monolithic assumptions: Assumes a traditional MVC Laravel app; may clash with microservices or event-driven architectures.

Migration Path

1. Pre-Integration Phase:
   • Audit: Review existing order/payment/delivery models, DB schema, and API integrations.
   • Dependency Check: Verify baks-dev/yandex-market compatibility with other packages (e.g., no version conflicts).
   • Environment Setup: Isolate a staging environment for testing.
2. Installation:
   • Composer install:

     composer require baks-dev/yandex-market baks-dev/yandex-market-orders
     

   • Run setup commands (FBS/DBS) based on marketplace type.
   • Install assets and migrations:

     php bin/console baks:assets:install
     php bin/console doctrine:migrations:diff
     php bin/console doctrine:migrations:migrate
     

3. Configuration:
   • Set up Yandex Marketplace API credentials in .env (e.g., YANDEX_MARKET_FBS_TOKEN).
   • Configure payment/delivery settings in Laravel config (likely in config/yandex-market.php).
4. Customization:
   • Override Defaults: Use Laravel’s bindings or service providers to extend:
     • Order processing logic (e.g., YandexMarketOrderService).
     • Payment webhook handlers.
     • Delivery status updates.
   • Example:

     // app/Providers/YandexMarketServiceProvider.php
     public function register()
     {
         $this->app->bind(
             YandexMarketOrderService::class,
             fn() => new CustomYandexMarketOrderService()
         );
     }
     

5. Testing:
   • Run package tests:

     php bin/phpunit --group=yandex-market-orders
     

   • Add integration tests for critical flows (e.g., order creation, payment capture).

Compatibility

• Database:
  • Doctrine ORM Required: If using Eloquent, expect schema conflicts or need to adapt migrations.
  • Existing Tables: May need to extend (e.g., add Yandex-specific fields) rather than replace.
• APIs:
  • Yandex Marketplace API: Ensure rate limits, token rotation, and error handling are addressed.
  • Yandex.Kassa: Verify webhook URLs and async payment flow compatibility.
• Laravel Ecosystem:
  • Queue Workers: If using Laravel Queues, ensure async jobs (e.g., order processing) are configured.
  • Caching: Package may rely on caching for API tokens; align with Laravel’s cache drivers.

Sequencing

1. Phase 1: Core Integration (2-4 weeks):
   • Install package, run migrations, configure credentials.
   • Implement basic order flow (creation, status sync).
2. Phase 2: Payment/Delivery (1-2 weeks):
   • Set up Yandex.Kassa webhooks.
   • Integrate delivery status updates.
3. Phase 3: Customization (Ongoing):
   • Extend for unique business logic.
   • Add monitoring/logging.
4. Phase 4: Go-Live (1 week):
   • Test with Yandex Market sandbox.
   • Roll out to production with feature flags.

Operational Impact

Maintenance

• Dependency Updates:
  • Risk: baks-dev/yandex-market is unmaintained (last release 2026-04-29, but repo is new). Plan for:
    • Forking if critical bugs arise.
    • Backward compatibility checks for Laravel/PHP updates.
  • Strategy: Pin versions in composer.json; monitor for upstream changes.
• Configuration Drift:
  • Yandex Marketplace API changes (e.g., new endpoints, auth