Sharp Laravel Package

Technical Evaluation

Architecture Fit

Sharp is a Laravel-first CMS framework designed for structured content management, making it an excellent fit for projects requiring:

• Decoupled content management (no tight coupling to Sharp’s internals).
• API-driven content operations (CRUD, search, filtering, validation).
• Laravel conventions (Eloquent models, Blade templates, Inertia.js for frontend).
• Data-agnostic persistence (works with any database layer, including custom queries).

Key strengths:

• Code-first approach: No frontend code required for basic CMS operations (admin panels, forms, lists).
• Extensible via PHP API: Custom entities, commands, and workflows can be built without frontend changes.
• Inertia.js integration: Modern SPAs (React/Vue) can leverage Sharp’s backend while maintaining a decoupled frontend.
• Laravel 11+ compatibility: Aligns with modern Laravel features (e.g., model binding, middleware updates).

Potential misfits:

• Frontend-heavy projects: If the team prefers React/Vue for all UI layers (not just admin), Sharp’s Inertia.js dependency may require additional abstraction.
• Non-Laravel stacks: Not suitable for non-PHP backends (e.g., Node.js, Python).

Integration Feasibility

Key dependencies:

• Inertia.js: For admin UI (if not using Sharp’s default Blade templates).
• Blade Icons: For menu icons (optional but recommended).
• 2FA packages: pragmarx/google2fa-laravel and bacon/bacon-qr-code for TOTP.

Technical Risk

Critical questions:

1. Does the project already use Inertia.js? If not, evaluate the effort to adopt it for the admin panel.
2. Are there existing admin panels or CMS tools? Sharp may require significant migration effort.
3. Is 2FA a hard requirement? TOTP adds complexity; notification-based 2FA is simpler.
4. How will custom content types (e.g., e-commerce products) map to Sharp entities?
5. Are there legacy Laravel features (e.g., Blade directives, custom middleware) that conflict with Sharp?

Key Questions for Stakeholders

1. Business Goals:

   • Is the primary goal to replace an existing CMS (e.g., WordPress, Strapi) or add a Laravel-native CMS layer?
   • Are there specific content types (e.g., blog posts, products) that Sharp must support?

2. Technical Constraints:

   • What authentication system is currently in use? (Sharp integrates with Laravel’s auth.)
   • Is the team comfortable with Inertia.js for the admin UI, or is a custom frontend preferred?
   • Are there performance benchmarks for Sharp in similar-scale projects?

3. Operational Readiness:

   • Who will maintain Sharp-specific code (e.g., entities, commands)?
   • Is the team prepared for major version upgrades (Sharp’s breaking changes)?

4. Alternatives Considered:

   • Have other Laravel CMS packages (e.g., October CMS, Pyro CMS) been evaluated?
   • Would a headless CMS (e.g., Strapi + Laravel) be a better fit?

Integration Approach

Stack Fit

Sharp is optimized for Laravel 11+ stacks with the following components:

• Backend: Laravel (Eloquent, Blade, Inertia.js).
• Frontend: Inertia.js (React/Vue) or Blade templates.
• Database: Eloquent models or custom repositories.
• Auth: Laravel’s auth system (Breeze, Sanctum, etc.) + Sharp’s 2FA.
• UI: Tailwind CSS (Sharp’s default) or custom CSS.

Compatibility Matrix:

Migration Path

Phase 1: Evaluation (1–2 weeks)

1. Set up a Sharp sandbox:
   • Install Sharp in a new Laravel 11 project.
   • Test core features (entities, CRUD, search, 2FA).
2. Benchmark performance:
   • Compare Sharp’s query overhead vs. custom Eloquent.
3. Assess 2FA requirements:
   • Decide between notification-based or TOTP (see docs for tradeoffs).

Phase 2: Pilot Integration (2–4 weeks)

1. Define Sharp entities:
   • Map existing content models (e.g., Post, Product) to Sharp entities.
   • Example:

     class PostEntity extends SharpEntity
     {
         public function getModel(): string { return \App\Models\Post::class; }
         public function getTitleField(): string { return 'title'; }
         public function getListFields(): array { return ['title', 'published_at']; }
     }
     

2. Configure Sharp:
   • Replace config/sharp.php with SharpConfigBuilder (see upgrade guide).
   • Set up middleware (Inertia, filters, auth).
3. Integrate auth:
   • Extend Laravel’s auth with Sharp’s 2FA (notification or TOTP).
4. Build a minimal admin panel:
   • Use Sharp’s default UI or customize with Inertia components.

Phase 3: Full Rollout (4–8 weeks)

1. Migrate existing data:
   • Write data importers for Sharp entities (e.g., from WordPress XML).
2. Replace legacy CMS features:
   • Gradually replace custom admin panels with Sharp’s UI.
3. Customize workflows:
   • Extend Sharp with custom commands, validations, or workflows.
4. Deploy and monitor:
   • Roll out to staging, then production.
   • Monitor performance (Sharp adds middleware layers).

Phase 4: Optimization (Ongoing)

1. Fine-tune entities:
   • Optimize getListFields(), getFormFields(), and search queries.
2. Cache strategies:
   • Leverage Laravel’s cache for Sharp queries if needed.
3. Document Sharp-specific code:
   • Ensure future devs understand Sharp’s conventions (e.g., entities, commands).

Compatibility Considerations