Laravel Resources Typescript Laravel Package

Product Decisions This Supports

• API-Driven Frontend Development: Accelerates frontend development by auto-generating TypeScript types from Laravel API responses, reducing manual type definition work and improving developer velocity.
• Type Safety in Full-Stack Apps: Enables strong typing between Laravel backend (PHP) and frontend (TypeScript/JavaScript), catching errors early and improving maintainability.
• Adoption of Laravel Resources: Encourages consistent use of Laravel’s JsonResource pattern without forcing a full DTO migration, lowering the barrier to adoption.
• Developer Experience (DX) Improvements: Reduces context-switching between backend and frontend by keeping types in sync with API responses, lowering cognitive load.
• Scalability for Large Teams: Standardizes type definitions across microservices or monolithic apps, ensuring consistency in large codebases.
• Build vs. Buy Decision: Avoids reinventing type generation wheels (e.g., custom scripts or tools like OpenAPI/Swagger) when Laravel-specific needs are simpler and more maintainable.
• Roadmap for API-First Development: Supports future-proofing by aligning frontend types with backend changes automatically, reducing tech debt.

When to Consider This Package

• Use This When:

  • Your team uses Laravel 10+ with PHP 8.1+ and relies on JsonResource for API responses.
  • You need TypeScript types for frontend consumers of Laravel APIs without manual maintenance.
  • Your API responses are structured (arrays, objects, enums) and can be inferred from PHPDoc, ArrayShape, or public properties.
  • You want to avoid DTO-heavy abstractions but still need type safety.
  • Your frontend team works in TypeScript/JavaScript and benefits from auto-generated types.
  • You’re building a full-stack Laravel app where backend and frontend are tightly coupled.

• Look Elsewhere When:

  • Your API responses are highly dynamic or rely on runtime logic that can’t be statically analyzed (e.g., complex nested conditionals in toArray()).
  • You need runtime type validation (e.g., JSON Schema) alongside TypeScript types (consider spatie/laravel-json-api or OpenAPI tools).
  • Your stack uses non-Laravel backends (e.g., Symfony, Node.js) or non-TypeScript frontends (e.g., Python, Java).
  • You require advanced OpenAPI/Swagger documentation with examples, security definitions, or server URLs (use darkaonline/l5-swagger or zircote/swagger-php).
  • Your team prefers explicit DTOs over inferred types for better control over API contracts.
  • You’re in a greenfield project with no existing Laravel resources, and manual type definitions are trivial.

How to Pitch It (Stakeholders)

For Executives/Stakeholders:

*"This package eliminates a major friction point in our full-stack development workflow. By automatically generating TypeScript types from Laravel’s JsonResource classes, we can:

• Cut frontend development time by 30–50% (no manual type definitions or API documentation).
• Reduce bugs with compile-time type checking between our Laravel backend and TypeScript frontend.
• Lower maintenance costs by keeping types in sync with API changes—no more broken frontend types after backend updates.
• Future-proof our API layer without forcing a heavy DTO migration, saving engineering time.

It’s a lightweight, zero-config solution for teams already using Laravel and TypeScript. The cost? Almost nothing—just a Composer package. The ROI? Faster iterations, fewer errors, and happier developers."*

For Engineering Teams:

*"This package solves the ‘type mismatch’ problem between Laravel and TypeScript by:

1. Auto-generating TypeScript interfaces from your existing JsonResource classes, including:
   • Arrays, objects, and enums.
   • PHPDoc annotations (@var, @property).
   • PHP 8.1+ attributes (#[ArrayShape]).
   • Eloquent $fillable fields.
   • Dynamic toArray() responses (if structured predictably).
2. Falling back to any safely for ambiguous cases, so it never breaks your build.
3. Working out-of-the-box with Laravel 10–13 and PHP 8.1+—no complex setup.

Why use this over alternatives?

• No DTO overhead: Works with your existing resources; no need to rewrite API layers.
• No runtime bloat: Purely a dev-time tool (no impact on production).
• Laravel-native: Understands Laravel’s quirks (e.g., HasMany, BelongsTo) better than generic OpenAPI tools.

Trade-offs:

• Not a replacement for OpenAPI if you need runtime validation or docs.
• Best for structured APIs; complex dynamic responses may need manual tweaks.

Next Steps:

1. Add the package (composer require diephp/laravel-resources-typescript).
2. Run php artisan resources:typescript to generate types.
3. Import types in your frontend (e.g., import type { UserResource } from './generated').

Let’s prototype this on [Project X] to validate the time savings!"*