Revive Laravel Package

Technical Evaluation

Architecture Fit

• Soft-Delete Compatibility: The package is designed for Laravel Eloquent models with soft-deletes enabled (SoftDeletes trait). This aligns well with applications using deleted_at timestamps for recovery workflows.
• Filament Integration: Tightly coupled with FilamentPHP (v5+), making it ideal for admin panels built on Filament. If the product already uses Filament, this reduces friction.
• Centralized Recycle Bin: Provides a unified UI for managing soft-deleted records across multiple models, reducing the need for ad-hoc restore logic in individual resources.
• Extensibility: Supports customization via model policies, resource configurations, and bulk actions, allowing alignment with existing access control and workflows.

Integration Feasibility

• Laravel Ecosystem Fit: Leverages Eloquent’s soft-delete capabilities and Filament’s resource system, minimizing custom integration work.
• Model-Specific Configuration: Requires minimal setup per model (e.g., defining revive() methods in resources), but this is offset by Filament’s declarative syntax.
• UI/UX Alignment: The recycle bin UI is pre-built, reducing frontend development effort. However, styling may need adjustments to match the product’s design system.
• Database Impact: No schema changes are required, but queries may include additional WHERE deleted_at IS NOT NULL clauses, which could impact performance for large datasets.

Technical Risk

• Filament Version Lock: The package is actively developed for Filament v5, so adoption of an older Filament version (e.g., v3/v4) may require backporting or forking.
• Model-Specific Quirks: Some Eloquent models (e.g., those with custom soft-delete logic or non-standard timestamps) may need additional configuration.
• Bulk Operations: While bulk restore/delete is supported, edge cases (e.g., foreign key constraints, model-specific validation) may require custom handling.
• Testing Overhead: Integration testing for restore/delete workflows (e.g., event listeners, observers) must be validated to ensure data consistency.

Key Questions

1. Filament Version: Is the product using Filament v5, or would migration to v5 be required? If not, what’s the upgrade path for promethys/revive?
2. Model Coverage: Which models require recycle bin functionality? Are there models with non-standard soft-delete behavior (e.g., custom columns, observers)?
3. Access Control: How are restore/delete permissions managed in the product? Does the package’s policy system align with existing RBAC?
4. Performance: What’s the expected volume of soft-deleted records? Are there concerns about query performance or database bloat?
5. UI Customization: Does the product have a design system? How much effort is needed to align the recycle bin UI with existing styles?
6. Audit Logging: Are restore/delete actions logged elsewhere (e.g., Laravel Audit, custom logs)? If so, how will this package’s actions be integrated?
7. Backup Strategy: How are soft-deleted records handled in backups? Could the recycle bin complicate restore-from-backup workflows?

Integration Approach

Stack Fit

• Primary Use Case: Ideal for Filament-based admin panels in SaaS, CMS, or multi-tenant applications where data recovery is critical.
• Laravel Compatibility: Works with Laravel 10+ (assuming Filament v5 compatibility). Ensure the product’s Laravel version is supported.
• Database Agnostic: No database-specific logic; works with MySQL, PostgreSQL, SQLite, etc.
• Event-Driven Extensions: Can be extended with Laravel events (e.g., ReviveRestored, RevivePermanentlyDeleted) for custom workflows.

Migration Path

1. Assessment Phase:
   • Audit existing soft-delete usage across models.
   • Verify Filament version and compatibility.
   • Identify models requiring recycle bin support.
2. Setup:
   • Install the package via Composer:

     composer require promethys/revive
     

   • Publish and configure the package (e.g., config/revive.php).
   • Register the recycle bin resource in app/Providers/Filament/AdminPanelProvider.php.
3. Model Integration:
   • For each target model, define revive() in its Filament resource to enable recycle bin functionality.
   • Example:

     public static function revive(): array
     {
         return [
             'name' => 'posts',
             'label' => 'Posts',
             'model' => \App\Models\Post::class,
         ];
     }
     

4. Customization:
   • Override default views or styles to match the product’s design system.
   • Extend policies or add custom logic (e.g., pre-restore validation).
5. Testing:
   • Test soft-delete, restore, and permanent delete workflows.
   • Validate edge cases (e.g., bulk operations, foreign key constraints).

Compatibility

• Filament v5: Full feature support.
• Filament v4: Limited to v2.x of the package (maintenance mode).
• Legacy Systems: If using Filament v3 or custom admin panels, the package may not be directly applicable; alternatives like custom middleware or packages like spatie/laravel-activitylog would need evaluation.
• Non-Eloquent Models: Not supported; only Eloquent models with SoftDeletes are compatible.

Sequencing

1. Phase 1: Pilot with 1–2 non-critical models to validate integration and performance.
2. Phase 2: Roll out to core models, ensuring UI/UX alignment and access control.
3. Phase 3: Extend with custom features (e.g., event listeners, audit logging).
4. Phase 4: Monitor usage and performance; optimize queries or add caching if needed.

Operational Impact

Maintenance

• Package Updates: Monitor promethys/revive for Filament v5 updates and backport critical fixes if using an older version.
• Dependency Management: Ensure compatibility with Filament, Laravel, and other dependencies (e.g., PHPUnit, Pest).
• Configuration Drift: Document model-specific configurations (e.g., revive() methods) to avoid inconsistencies during updates.

Support

• User Training: Admins/users will need training on the recycle bin workflow (e.g., restore vs. permanent delete).
• Documentation: Update internal docs to reflect the new feature, including:
  • How to access the recycle bin.
  • Permissions required for restore/delete actions.
  • Limitations (e.g., non-recoverable deletions, bulk operation constraints).
• Troubleshooting: Prepare for common issues like:
  • Models not appearing in the recycle bin (check revive() configuration).
  • Permission errors (validate policies).
  • Performance degradation (query optimization).

Scaling

• Database Load: Soft-deleted records accumulate over time. Consider:
  • Adding a revive_expires_at column to auto-purge old records.
  • Implementing a cron job to archive or delete very old soft-deleted records.
• Query Optimization: For large datasets, add indexes on deleted_at or paginate recycle bin results.
• Caching: Cache recycle bin metadata (e.g., counts per model) if the UI supports it.

Failure Modes

• Data Loss: Permanent delete actions are irreversible. Mitigate with:
  • Confirmation dialogs for delete actions.
  • Audit logs for all restore/delete operations.
• UI Freezes: Slow queries on large recycle bin datasets. Mitigate with:
  • Pagination or lazy-loading.
  • Database optimization (e.g., partial indexes on deleted_at).
• Permission Bypass: Improper policy configuration could allow unauthorized restores. Mitigate with:
  • Role-based access control (RBAC) validation.
  • Regular audits of recycle bin permissions.

Ramp-Up

• Developer Onboarding:
  • 1–2 hours to understand the package’s core functionality.
  • Additional time for customizations (e.g., policies, UI tweaks).
• Testing Overhead:
  • Add test cases for soft-delete workflows (e.g., restore, permanent delete, bulk actions).
  • Validate edge cases (e.g., models with observers, custom soft-delete logic).
• Release Coordination:
  • Align with Filament/Laravel updates to avoid compatibility issues.
  • Communicate changes to stakeholders (e.g., "Recycle Bin now available for Posts and Users").
• Feedback Loop:
  • Gather user feedback on usability (e.g., UI clarity, workflow efficiency).
  • Iterate on documentation or features based on pain points.