Utils Laravel Package

Technical Evaluation

Architecture Fit

• Pros:

  • Modular Design: The package’s granular utilities (e.g., Strings, Arrays, Process, Image) align well with Laravel’s service-layer architecture. Each utility can be injected as a service provider or facade, reducing boilerplate in controllers/services.
  • PHP 8.2+ Compatibility: Laravel 10+ (PHP 8.2+) ensures seamless integration with modern PHP features (e.g., enums, typed properties, union types).
  • Security-First: Features like Process::runExecutable() (shell-injection-safe) and FileSystem::isValidFilename() mitigate common Laravel vulnerabilities (e.g., file uploads, CLI commands).
  • Performance: Optimized methods (e.g., Iterables::memoize(), Arrays::filter()) can replace manual loops in Eloquent queries or collection transformations, improving TTFB.
  • Validation Layer: The Type and Validators classes can replace or extend Laravel’s built-in validation (e.g., custom rules for APIs, form requests).

• Cons:

  • Niche Overlap: Some utilities (e.g., Html, Json) overlap with Laravel’s native helpers (Str::, Json::). Risk of duplication if not scoped carefully.
  • GD/Intl Dependencies: Image handling and Unicode features require extensions, which may not be enabled in all Laravel deployments (e.g., shared hosting).
  • Opinionated APIs: Methods like Strings::webalize() use Nette’s conventions (e.g., PascalCase constants), which may require adaptation for Laravel’s snake_case style.

Integration Feasibility

• Laravel Ecosystem Synergy:
  • Service Providers: Register utilities as singletons (e.g., Nette\Utils\Strings) in AppServiceProvider::boot().
  • Facades: Create custom facades (e.g., Utils::slugify()) to mimic Laravel’s Str:: pattern.
  • Blade Directives: Extend Blade with helpers (e.g., @slug($text)) using Blade::directive().
  • Validation: Integrate Validators into Laravel’s pipeline via Validator::extend() or custom rules.
• Database/ORM:
  • Eloquent Accessors: Use Arrays::mapWithKeys() to transform query results (e.g., pivot tables).
  • Query Scoping: Leverage Iterables::memoize() to cache repetitive subqueries.
• Artisan/CLI:
  • Replace Artisan::call() with Process::runExecutable() for safer subprocess calls (e.g., Process::runExecutable('php', ['artisan', 'queue:work'])).

Technical Risk

Key Questions

1. Prioritization:
   • Which utilities will deliver the highest ROI? (e.g., Process for CLI workflows, Image for media-heavy apps).
   • Should we replace Laravel’s native helpers (e.g., Str::) or complement them?
2. Dependency Management:
   • How will we handle minor version upgrades (e.g., PHP 8.5 support in v4.0.9) without breaking Laravel?
3. Team Adoption:
   • Will developers prefer Nette’s PascalCase or Laravel’s snake_case? (Solution: Facades/aliases.)
4. Security:
   • How will we audit Process::runCommand() usage to prevent accidental shell injection?
5. Long-Term Maintenance:
   • Should we fork the package to customize APIs or contribute upstream to influence future versions?

Integration Approach

Stack Fit

• Laravel Core:
  • Service Container: Bind utilities as singletons in AppServiceProvider:

    $this->app->singleton('nette.utils.strings', fn() => new \Nette\Utils\Strings());
    

  • Facades: Create Utils facade to expose methods like Utils::slug().
  • Validation: Extend Laravel’s validator:

    Validator::extend('nette_filename', function ($attr, $value, $params) {
        return \Nette\Utils\FileSystem::isValidFilename($value);
    });
    

• Eloquent:
  • Accessors/Mutators: Use Arrays::mapWithKeys() to transform attributes:

    public function getSlugAttribute($value) {
        return \Nette\Utils\Strings::webalize($this->attributes['title']);
    }
    

  • Query Scoping: Cache repetitive subqueries with Iterables::memoize().
• Blade:
  • Register directives for templating:

    Blade::directive('slug', function ($text) {
        return "<?php echo \\Nette\\Utils\\Strings::webalize({$text}); ?>";
    });
    

• Artisan/CLI:
  • Replace Artisan::call() with Process::runExecutable() for safer subprocesses:

    $process = new \Nette\Utils\Process();
    $process->runExecutable('php', ['artisan', 'queue:work', '--once']);
    

• APIs/Forms:
  • Use Validators for custom rules:

    'filename' => ['nette_filename', 'required'],
    

Migration Path

1. Phase 1: Proof of Concept (2 weeks)

   • Integrate 3 high-impact utilities (e.g., Strings, Process, Validators) into a single module.
   • Benchmark performance vs. Laravel natives (e.g., Str::slug() vs. Strings::webalize()).
   • Document edge cases (e.g., Unicode handling in Strings::trim()).

2. Phase 2: Core Integration (4 weeks)

   • Publish utilities as composer packages (e.g., laravel-nette-utils) with Laravel-specific facades.
   • Add PHPStan/Psalm rules to enforce type safety.
   • Train team on facade vs. direct usage patterns.

3. Phase 3: Full Adoption (Ongoing)

   • Replace legacy helpers (e.g., custom slug() functions) with Nette utilities.
   • Deprecate overlapping Laravel natives (e.g., Str::) via deprecation warnings.

Compatibility

Sequencing

1. Critical Path:

   • Process Management: Highest risk (shell injection), prioritize for CLI workflows.
   • String/Array Utilities: Broad impact (CMS, APIs, forms).
   • Image Handling: For media-heavy apps (e.g., e-commerce, galleries).

2. Low-Risk Add-ons:

   • Validation: Complement Laravel’s rules.
   • Iterables: Optimize query performance.
   • DateTime: Replace Carbon for relative time calculations.

3. Deprecation Plan:

   • Phase out custom slug() functions in favor of Strings::webalize().
   • Deprecate Str:: methods with Nette alternatives (e.g., Str::slug() → Utils::slug()).

Operational Impact

Maintenance

• Pros:
  • Reduced Boilerplate: Utilities eliminate repetitive code (e.g., slug generation, file validation).
  • Consistent APIs: Nette’s utilities enforce type safety and **edge