Case Bundle Laravel Package

Product Decisions This Supports

• Expanded Case Format Support: Adds kebab-case conversion (e.g., user-first-name ↔ userFirstName), enabling broader alignment with frontend frameworks (React/Vue) and modern API design trends (e.g., GraphQL, RESTful endpoints). This reduces friction in polyglot persistence scenarios where kebab-case is preferred for URLs or frontend state.
• Unified Case Transformation Pipeline: Strengthens the "write once, use anywhere" roadmap by supporting all 5 major case formats (snake_case, camelCase, PascalCase, Title Case, kebab-case) in a single package. Ideal for systems integrating with:
  • Frontend frameworks (e.g., Vue’s kebab-case props, React’s camelCase).
  • URL routing (e.g., /users/first-name vs /users/firstName).
  • Third-party APIs (e.g., Stripe’s snake_case ↔ Shopify’s camelCase ↔ your kebab-case internal IDs).
• Build vs. Buy Justification: Eliminates the need to maintain custom kebab-case logic (e.g., regex-heavy str_replace chains) or rely on ad-hoc solutions like Inflector (which lacks Laravel/Symfony integration). The package now covers 90%+ of case-conversion needs in a PHP monorepo.
• Use Cases (Updated):
  • URL/Route Generation: Auto-convert userFirstName → user-first-name for SEO-friendly slugs (e.g., Route::get('/users/{name}', ...)).
  • GraphQL Schema Alignment: Normalize GraphQL field names (kebab-case) to backend DB fields (snake_case) without manual mapping.
  • CMS/Headless CMS: Standardize content model fields (e.g., post-title in Strapi → postTitle in PHP).
  • Legacy System Integration: Bridge old kebab-case APIs (e.g., /api/v1/user-first-name) with modern camelCase services.

When to Consider This Package

• Look Elsewhere If:
  • Performance-Critical Paths: Kebab-case conversion adds minimal overhead, but for high-frequency string processing (e.g., 100K+ conversions/sec), benchmark against:
    • Native PHP: preg_replace('/-([a-z])/e', 'strtoupper("$1")', str_replace('-', ' ', $str)).
    • league/uri for URL-specific kebab-case needs.
  • Overkill for Simple Projects: If your stack uses only 1–2 case formats (e.g., snake_case DB + camelCase API), the package’s breadth may be unnecessary. A lightweight utility like spatie/array-to-string could suffice.
  • Non-PHP Ecosystems: For Node.js/Python, use native tools (e.g., lodash.kebabCase, inflection.kebabize).
  • Symfony’s StringUtils Already Covers Needs: If you’re using Symfony 6.3+ and only need kebab-case for URLs, symfony/web-link or symfony/string may integrate better with your existing stack.
• Adopt If:
  • You work with kebab-case in URLs, frontend props, or third-party APIs (e.g., Algolia, Contentful).
  • Your team needs consistent kebab-case generation (e.g., for SEO slugs, GraphQL fields, or route parameters).
  • You’re migrating between multiple case formats (e.g., snake_case DB → kebab-case API → camelCase frontend) and want a single source of truth.
  • You value developer experience: Reduces cognitive load by centralizing case logic (e.g., no more debating whether user-first-name or userFirstName is "correct").

How to Pitch It (Stakeholders)

For Executives: *"This update adds kebab-case support, which is critical for modern web apps. For example:

• SEO/URLs: Automatically convert userFirstName to user-first-name for clean, readable URLs (e.g., /users/user-first-name).
• Frontend Integration: Align with React/Vue’s kebab-case prop conventions without manual string manipulation.
• Third-Party APIs: Standardize interactions with services that use kebab-case (e.g., Stripe, Contentful).

Impact:

• Saves 10–20 hours/year in dev time by eliminating ad-hoc case conversions.
• Reduces bugs in data flows between backend (snake_case), API (kebab-case), and frontend (camelCase).
• Future-proofs the codebase for new integrations (e.g., GraphQL, headless CMS).

Cost: Zero—just a Composer update. ROI comes from consistency and reduced technical debt."*

For Engineers: *"v1.3.0 adds kebab-case, which is a game-changer for:

• URL/Route Handling: Generate SEO-friendly slugs with toKebabCase() (e.g., UserFirstName → user-first-name).
• GraphQL/REST APIs: Normalize field names between kebab-case (GraphQL) and snake_case (DB).
• Frontend Alignment: Match Vue/React prop conventions without manual str_replace hacks.

Key Features:

• All 5 case formats in one package: snake_case, camelCase, PascalCase, Title Case, kebab-case.
• Array support: Convert batches of strings (e.g., ['user_first_name', 'user_last_name'] → ['user-first-name', 'user-last-name']).
• Twig integration: Use in templates like {{ "UserFirstName"|toKebabCase }}.
• Zero breaking changes: Backward-compatible with existing toCamelCase(), etc.

Example:

$converter->toKebabCase(['userFirstName', 'userLastName']);
// => ['user-first-name', 'user-last-name']

Trade-offs:

• Adds ~1KB to bundle size (negligible).
• Kebab-case logic is slightly more complex than camelCase (handles hyphen placement), but optimized for readability."*

For Architects: *"This update completes the case-conversion matrix for our stack, enabling:

1. Polyglot Persistence: Seamlessly transform between DB (snake_case), API (kebab-case), and frontend (camelCase).
2. URL/Slug Standardization: Centralize kebab-case generation for routes, SEO, and third-party integrations.
3. GraphQL Readiness: Align with GraphQL’s kebab-case field naming convention without custom logic.

Recommendation:

• Adopt for projects using kebab-case in URLs, frontend props, or APIs.
• Pair with Symfony’s StringUtils if you’re already using it for other string ops (e.g., slugify).
• Avoid if: You only need kebab-case for URLs (use symfony/web-link instead) or have a minimalist stack.

Long-Term Value:

• Reduces context-switching for devs working across layers.
• Future-proofs for new case formats (e.g., space-case for human-readable outputs)."*