Resource Bundle Laravel Package

Product Decisions This Supports

• Decoupling Content Management from Application Logic: Adopt this package to abstract pre-produced data (e.g., CMS-driven content, configurations, or assets) from application code. Enables teams to manage content independently of deployment cycles, reducing friction for non-technical stakeholders (e.g., marketers, designers).

• Multi-Tenant or Multi-Language Support: Leverage ResourceTenant and ResourceLanguage to dynamically load tenant-specific or language-localized resources (e.g., regional legal disclaimers, localized UI strings). Aligns with roadmaps for global expansion or compliance-driven features.

• Performance Optimization: Use lazy-loading (e.g., lazy-load service atoolo_resource.resource_channel) and cached loading (CachedResourceLoader) to reduce initial load times for resource-heavy applications (e.g., e-commerce product catalogs, documentation portals).

• Build vs. Buy: Buy: If your team lacks bandwidth to build a custom resource management system (RMS) from scratch, this package provides a battle-tested foundation with Symfony/Laravel integration. Build: Only if you need highly specialized resource hierarchies or real-time synchronization with external systems (e.g., GraphQL subscriptions).

• Use Cases:

  • Headless CMS Integration: Fetch and transform CMS content (e.g., Sitepark IES) into structured PHP objects for APIs or frontend frameworks.
  • Dynamic Configuration: Load environment-specific configurations (e.g., feature flags, API endpoints) without hardcoding.
  • Asset Management: Serve localized or tenant-specific assets (images, videos) with metadata (e.g., ResourceLocation::ofPath()).

When to Consider This Package

Adopt if:

• Your application relies on pre-produced data (e.g., CMS content, static configs) that changes infrequently but requires dynamic loading.
• You need multi-tenancy or multi-language support with minimal boilerplate.
• Your stack includes Laravel/Symfony and you want to avoid reinventing resource loading logic.
• Performance is critical, and you can leverage caching or lazy-loading for resource-heavy workflows.
• Your team prioritizes developer velocity over customization (MIT license, active maintenance).

Look elsewhere if:

• You require real-time data synchronization (e.g., WebSocket updates) or active editing of resources (consider a dedicated CMS API).
• Your resources are highly dynamic (e.g., user-generated content) and need CRUD operations—this package focuses on read-heavy use cases.
• You’re not using PHP 8.2+ or Symfony/Laravel (compatibility is limited).
• You need graph traversal or complex relationships beyond hierarchical resource loading (e.g., graph databases like Neo4j).
• Your team lacks PHP/Symfony expertise to integrate or debug the package.

How to Pitch It (Stakeholders)

For Executives: *"This package lets us treat content like a first-class citizen in our Laravel/Symfony apps—without sacrificing performance or flexibility. By abstracting pre-produced data (e.g., CMS content, configs) into reusable ‘bundles,’ we can:

• Ship faster: Non-technical teams update content independently of deployments.
• Scale globally: Dynamically load tenant/language-specific resources (e.g., regional legal pages) with minimal code.
• Optimize costs: Lazy-load and cache resources to reduce server load and improve response times. It’s a ‘buy’ decision that saves dev time and aligns with our roadmap for [global expansion/compliance/headless CMS]."*

For Engineering: *"This is a lightweight, Symfony-compatible library to manage structured, pre-produced data (e.g., from Sitepark IES or static files). Key benefits:

• Out-of-the-box features:
  • Multi-tenancy (ResourceTenant) and localization (ResourceLanguage).
  • Lazy-loading and caching (CachedResourceLoader) for performance.
  • Hierarchical resource loading (e.g., nested configs, asset trees).
• Integration:
  • Works with Laravel/Symfony; minimal setup (e.g., atoolo_resource.resource_host config).
  • PHP 8.2+ support with strict typing and PHPStan level 9.
• Trade-offs:
  • Not for real-time data; focus is on read-heavy workflows.
  • Limited community (0 stars/dependents), but active maintenance (releases every ~2 months). Recommendation: Pilot for [use case X] (e.g., product catalog, docs portal) to validate performance and ease of use before wider adoption."*

For Developers: *"Need to load CMS content, configs, or assets dynamically? This package handles it with:

• Zero boilerplate: Load resources by path/channel with ResourceLocation::ofPath().
• Flexible caching: Clear caches per tenant/language via CachedResourceLoader.
• Debugging tools: PHPStan-level 9 compliance and comprehensive tests. Example:

// Load a resource channel (e.g., 'products') with lazy loading
$resourceChannel = $this->resourceChannelService->get('products');
$product = $resourceChannel->get('shoes', 'en_US'); // Language fallback if missing

Try it: Replace your custom resource loader with this for [specific feature]—it’s faster to implement and more maintainable."*