Dict Laravel Package

Product Decisions This Supports

• Standardized Data Structures: Replace ad-hoc associative arrays with a structured Dict class to enforce consistency across configuration, request payloads, and dynamic attributes (e.g., user metadata, plugin settings). This reduces ambiguity and bugs by replacing implicit array access ($array['key']) with explicit methods (dict->get('key')).
• Configuration Management: Centralize app settings, feature flags, or environment variables into type-safe Dict instances with built-in merging, defaults, and validation. Aligns with Laravel’s config() system but adds a programmatic layer for runtime overrides.
• Attribute Stores: Model dynamic entity attributes (e.g., Eloquent model metadata, API request extensions) with a CRUD-friendly API, reducing boilerplate for isset() checks and nested array operations.
• Bulk Data Transformations: Streamline operations like merging user preferences with defaults, filtering sensitive keys, or updating nested structures in a single method call (e.g., dict->merge($overrides)).
• Laravel Ecosystem Alignment: Integrate seamlessly with Laravel’s Collection patterns for iteration and chaining, easing adoption for teams familiar with Laravel’s fluent interfaces.
• Build vs. Buy: Avoid reinventing dictionary abstractions (e.g., custom array wrappers or Symfony’s OptionsResolver) when this package offers a lightweight, MIT-licensed solution with no dependencies.
• Roadmap Priorities:
  • PHP 8.2+ Adoption: Leverage typed properties for stricter type safety in Dict implementations.
  • Configuration Refactoring: Migrate from raw arrays to Dict for app settings, feature flags, or third-party integrations.
  • API Layer Improvements: Standardize request/response payloads using Dict for validation and transformation consistency.

When to Consider This Package

• Adopt if:

  • Your codebase relies on raw arrays for associative data but lacks consistency (e.g., mixed isset()/?? patterns, nested array hell).
  • You need a lightweight alternative to Laravel’s Collection for simple key-value operations (lower overhead than full collections).
  • Configuration or attribute management is fragmented across arrays/objects, and you want a unified API with defaults/merging.
  • Your team prioritizes explicit intent over implicit array access (e.g., dict->set('key', $value) vs. $array['key'] = $value).
  • You’re using PHP 8.2+ and want to adopt stricter type safety without heavy frameworks like Symfony.
  • You’re building a new Laravel module where data structure consistency is a priority.

• Look elsewhere if:

  • You need advanced collection features (e.g., complex aggregations, lazy loading) → Use Laravel’s Collection or Illuminate\Support\Enumerable.
  • Your use case requires immutability or functional programming patterns → Consider spatie/array-to-object or league/arrayobjects.
  • Performance is critical for high-frequency operations (microbenchmarks may show raw arrays are faster for simple cases).
  • You’re already using a dedicated config package (e.g., Laravel’s Config facade) that handles merging/validation natively.
  • The team prefers native PHP arrays for flexibility and rejects additional abstraction overhead.
  • You need Laravel-specific integrations (e.g., Arrayable, Jsonable) out of the box (this package requires manual implementation).

How to Pitch It (Stakeholders)

For Executives:

"This package standardizes how we handle associative data in PHP—replacing raw arrays with a structured Dict class to reduce bugs and improve maintainability. For example, instead of scattered isset() checks or ?? operators, we’d use dict->get('key', default), cutting down on errors and making the codebase more predictable. It’s especially valuable for configuration management and dynamic attributes, where consistency saves development time. With no dependencies and minimal overhead, it’s a low-risk way to enforce best practices across the codebase."

For Engineering:

*"php-standard-library/dict gives us a thin, Laravel-friendly wrapper for arrays with key benefits:

• Type-safe access: Methods like get(), set(), and has() with defaults replace isset() spaghetti.
• Bulk operations: Merge, update, or filter dictionaries in one call (e.g., dict->merge($overrides)).
• Iteration support: Works with foreach and collection-style loops.
• Zero dependencies: Just drop it into Laravel or plain PHP.

Top use cases:

• Configuration: Replace raw arrays in config() calls with Dict instances for safer access.
• Request handling: Normalize input data into Dict for consistent validation/transformation.
• Attribute stores: Extend Eloquent models or DTOs with Dict for dynamic metadata.
• API responses: Convert Dict to JSON/arrays with custom serialization.

Tradeoffs:

• Slightly slower than raw arrays (but negligible for most use cases).
• No built-in Laravel integrations (e.g., Arrayable requires manual implementation).

Proposal: Pilot in one module (e.g., config management) to measure readability gains before broader adoption. Start with opt-in usage in new features, then enforce via static analysis (PHPStan)."*

For Developers:

*"Tired of isset($array['key']) or ?? operators? Dict gives you:

// Before
$theme = $config['theme'] ?? 'light';

// After
$dict = new Dict($config);
$theme = $dict->get('theme', 'light');

• Safer: No more undefined index errors.
• Cleaner: Explicit methods for get/set/has.
• Powerful: Merge, update, or filter dictionaries in one call.
• Laravel-friendly: Works with collections and service containers.

Try it:

1. Replace raw arrays in config files or request payloads.
2. Use Dict::fromArray() to normalize input data.
3. Extend Eloquent models with a Dict trait for dynamic attributes.

Need more? We can add Laravel-specific features (e.g., Arrayable support) as needed."*