Array Laravel Package

Product Decisions This Supports

• Feature Development:

  • Data Transformation: Accelerate development of features requiring complex array manipulations (e.g., nested data restructuring, object-to-array conversions, or multi-level filtering). Reduces boilerplate code for common operations like map, filter, group, and sort.
  • API/Backend Logic: Simplify handling of hierarchical data (e.g., JSON payloads, configuration arrays, or database query results) with methods like Arr::set(), Arr::get(), and Arr::has() for nested access.
  • Object-Relational Mapping (ORM) or Collections: Streamline operations on collections of objects (e.g., sorting by method calls with Arr::sortObjects(), grouping with Arr::groupObjects()).
  • Data Validation: Quickly validate or sanitize arrays (e.g., checking for required keys with Arr::has() or ensuring data integrity with Arr::check()).

• Roadmap Prioritization:

  • Prototype-to-Production: Ideal for MVPs or rapid iterations where array manipulation logic is critical but not yet standardized. Justify "build vs. buy" by reducing dev time for ad-hoc data processing.
  • Legacy Code Modernization: Replace outdated or inconsistent array-handling logic (e.g., manual recursion for nested arrays) with a maintainable, tested library.
  • Performance-Critical Paths: Leverage PHP 7+ optimizations for operations like Arr::sum() or Arr::flatten() in high-throughput systems (e.g., batch processing).

• Use Cases:

  • Admin Panels/Dashboards: Dynamically reorder, filter, or aggregate data for UI display (e.g., Arr::orderByKeys() for configurable column sorting).
  • Reporting Tools: Compute aggregates (e.g., Arr::sum()) or group data (e.g., Arr::groupObjects()) for analytics.
  • Configuration Management: Safely merge or validate nested configuration arrays (e.g., Arr::set() for default values, Arr::diffObjects() for change detection).
  • Event-Driven Systems: Process nested event payloads or transform data between layers (e.g., Arr::mapObjects() for event handlers).

When to Consider This Package

• Adopt When:

  • Your team frequently handles nested arrays or objects and lacks standardized utility functions.
  • You need chaining support (e.g., fluent interfaces like Arr::obj()->set()->remove()->getArray()) to reduce temporary variable clutter.
  • PHP 7.4+ is your baseline, and you want to avoid external dependencies (e.g., no Laravel/Illuminate required).
  • You prioritize developer velocity over micro-optimizations, as the package trades some low-level control for readability.
  • Your use cases align with the documented methods (e.g., heavy use of group, sort, or flatten operations).

• Look Elsewhere When:

  • You’re using Laravel and already have Illuminate\Support\Arr (this package is a standalone alternative with some overlapping but extended functionality).
  • You need reactive/streaming array processing (this package works synchronously).
  • Your arrays are extremely large (memory-intensive operations like Arr::flatten() may not be optimal; consider generators or chunking).
  • You require type safety beyond PHP’s native typing (e.g., strict generics; this package uses runtime checks).
  • The last release (2020) is a blocker for your project’s maintenance policies (though MIT license and tests mitigate risk).

How to Pitch It (Stakeholders)

For Executives:

*"This package lets our team build data-processing features faster by replacing custom array-handling code with a battle-tested, MIT-licensed library. For example:

• Reduce dev time for features like dynamic data restructuring (e.g., APIs, reports) by 30–50%.
• Improve code quality with consistent, documented methods for nested arrays/objects (e.g., Arr::set('user.profile.name', $value) instead of manual recursion).
• Lower technical debt by standardizing array operations across teams, reducing bugs in ad-hoc logic. It’s a drop-in solution with no external costs, and its PHP 7 optimizations ensure performance won’t be a bottleneck. We’ve validated it in [X] use cases, including [specific feature or prototype]."

For Engineering:

*"minwork/array gives us a Laravel-like Arr helper but standalone, with superpowers:

• Chaining: Clean up verbose array transformations (e.g., Arr::obj($data)->filter()->map()->getArray()).
• Nested ops: Safe get/set/has for deeply nested structures (e.g., config, JSON APIs) without isset() spaghetti.
• Object support: Sort/group objects by method calls (e.g., Arr::sortObjects($users, 'getAge')).
• No Laravel bloat: Lightweight (~10KB), zero dependencies, and actively tested (90%+ coverage). *Use it for:
• Data pipelines (e.g., ETL, reporting).
• Complex form/config validation.
• Replacing array_map/array_filter with more expressive, debuggable code. Downside: Last updated in 2020, but the MIT license and tests make it low-risk. We can fork if needed."

Key Selling Point: "It’s like having a Swiss Army knife for arrays—but without the risk of Laravel’s Arr if we’re not using Laravel."