Constrained Morph To For Laravel Laravel Package

Getting Started

1. Installation: Add the package via Composer:

   composer require pindab0ter/constrained-morph-to-for-laravel
   

2. Basic Setup: Use the HasConstrainedMorphTo trait in your model and define a constrained morph-to relationship:

   use pindab0ter\ConstrainedMorphtoForLaravel\HasConstrainedMorphTo;
   
   class Comment extends Model
   {
       use HasConstrainedMorphTo;
   
       public function commentable()
       {
           return $this->constrainedMorphTo(Post::class, 'commentable_type', 'commentable_id');
       }
   }
   

3. First Use Case: Test with a valid and invalid model type to verify constraints:

   $post = Post::create(['title' => 'Test Post']);
   $comment = Comment::create([
       'commentable_id' => $post->id,
       'commentable_type' => Post::class,
   ]);
   // Returns the Post instance
   $comment->commentable;
   
   // Returns null (invalid type)
   $user = User::create(['name' => 'Test User']);
   $invalidComment = Comment::create([
       'commentable_id' => $user->id,
       'commentable_type' => User::class,
   ]);
   $invalidComment->commentable;
   

Implementation Patterns

Common Workflows

1. Single-Type Constraints:

   public function post()
   {
       return $this->constrainedMorphTo(Post::class, 'post_type', 'post_id');
   }
   

   • Use when a relationship must resolve to one specific model type (e.g., Comment → Post).

2. Multi-Type Constraints:

   public function commentable()
   {
       return $this
           ->constrainedMorphTo([Post::class, Video::class], 'commentable_type', 'commentable_id');
   }
   

   • Use for flexible polymorphic relationships (e.g., Comment → Post or Video).

3. Custom Column Names:

   public function owner()
   {
       return $this->constrainedMorphTo(
           User::class,
           'owner_model_type',  // Custom type column
           'owner_model_id',    // Custom ID column
           'owner'              // Custom relationship name
       );
   }
   

   • Use when your polymorphic columns deviate from Laravel’s defaults (*_type, *_id).

4. Integration with morphMap:

   class Comment extends Model
   {
       protected $morphClass = Comment::class;
   
       public function commentable()
       {
           return $this->constrainedMorphTo(
               ['App\Models\Post', 'App\Models\Video'],
               'commentable_type',
               'commentable_id'
           );
       }
   }
   

   • Ensure morphMap entries exist for all allowed types if using custom model names.

Best Practices

• Type Safety in Code: Use PHP 8.2+ generics for IDE autocompletion:

  /** @return ConstrainedMorphTo<Post, $this> */
  public function post() { ... }
  

• Database Migrations: Validate existing data before adoption:

  // Check for invalid morph types in a migration
  DB::table('comments')
      ->whereNotIn('commentable_type', [Post::class, Video::class])
      ->update(['commentable_type' => null]);
  

• Testing: Prioritize tests for:
  • Valid/invalid type resolution.
  • Edge cases (e.g., null IDs, non-existent models).
  • Interaction with with() or load() eager loading.

Advanced Patterns

1. Dynamic Constraints:

   public function dynamicOwner()
   {
       $allowedTypes = $this->getAllowedOwnerTypes(); // Fetch from config/API
       return $this->constrainedMorphTo($allowedTypes, 'owner_type', 'owner_id');
   }
   

   • Useful for role-based or tenant-specific constraints.

2. Composite Constraints:

   public function constrainedMorphToWithScope()
   {
       return $this->constrainedMorphTo(
           Post::class,
           'type',
           'id'
       )->where('published', true);
   }
   

   • Combine with query scopes for additional filtering.

3. Event Listeners:

   // Ensure constraints are validated on creation
   protected static function booted()
   {
       static::creating(function ($model) {
           if (!$model->isValidMorphType()) {
               throw new \InvalidArgumentException('Invalid morph type');
           }
       });
   }
   

Gotchas and Tips

Common Pitfalls

1. Silent Failures:

   • The package returns null for invalid types. Tip: Add a custom accessor to throw exceptions:

     public function getCommentableOrFail()
     {
         return $this->commentable ?: throw new \RuntimeException('Invalid commentable type');
     }
     

2. Case-Sensitive Class Names:

   • Ensure commentable_type in the database exactly matches the FQCN (e.g., App\Models\Post vs. app\Models\Post). Tip: Normalize class names in migrations:

     DB::table('comments')->update([
         'commentable_type' => str_replace('\\', '\\\\', Post::class),
     ]);
     

3. Caching Issues:

   • If using Laravel’s model caching, invalidated caches may return stale null results. Tip: Clear caches after updating constraints:

     php artisan cache:clear
     

4. Morph Map Conflicts:

   • If using morphMap, ensure all constrained types are registered. Tip: Add a check in a model observer:

     Morph::register([Post::class => 'posts']);
     

5. Serialization Quirks:

   • JSON/API responses may include null for invalid morphs. Tip: Use ->makeHidden() or custom JSON serialization:

     protected $hidden = ['commentable']; // Hide invalid relationships
     

Debugging Tips

• Log Invalid Types:

  public function commentable()
  {
      $result = $this->constrainedMorphTo([Post::class, Video::class], ...);
      if ($result === null) {
          \Log::warning("Invalid morph type for commentable: {$this->commentable_type}");
      }
      return $result;
  }
  

• Check Database Values:

  SELECT commentable_type, commentable_id FROM comments WHERE commentable_type NOT IN ('App\Models\Post', 'App\Models\Video');
  

• Verify Class Loading: Use get_declared_classes() to ensure all constrained models are autoloaded:

  dd(in_array(Post::class, get_declared_classes()));
  

Extension Points

1. Custom Constraint Logic: Override the constraint check in a service provider:

   ConstrainedMorphTo::macro('customConstraint', function ($callback) {
       return $this->constrainedMorphTo(...)->when(
           fn ($query) => $callback($query)
       );
   });
   

2. Add Validation Rules: Extend Laravel’s validation to reject invalid morph types:

   use Illuminate\Validation\Rule;
   
   $validator = Validator::make($data, [
       'commentable_type' => [
           'required',
           Rule::in([Post::class, Video::class]),
       ],
   ]);
   

3. Integrate with Policies: Use constraints in authorization:

   public function authorize()
   {
       return $this->commentable instanceof Post;
   }
   

Configuration Quirks

• No Package Config: The package relies on Eloquent conventions. Tip: Document your column names in a config/relationships.php file for consistency:

  return [
      'commentable' => [
          'type_column' => 'commentable_type',
          'id_column' => 'commentable_id',
          'allowed_types' => [Post::class, Video::class],
      ],
  ];
  

• Laravel 13+: Ensure you’re using the latest version for morphMap compatibility:

  composer require pindab0ter/constrained-morph-to-for-laravel:^1.2.0