Implement AlbumHasArtist relationship management with CRUD operations

This commit introduces the AlbumHasArtist join table entity management,
establishing the many-to-many relationship between Album and Artist
entities. This implementation follows the established repository pattern
used for other entities.

Key components implemented:

Model Layer:
- AlbumHasArtist entity representing the join table
- ManyToOne relationships to Album and Artist entities
- JPA annotations with proper foreign key constraints
- Complete getters and setters
- Custom toString method for debugging

Repository Layer:
- AlbumHasArtistRepository with EntityManager-based operations
- Full transaction management with proper rollback handling
- Methods: save, findAll, findById, deleteById
- No update method (join tables typically only need create/delete)

Service Layer:
- AlbumHasArtistService with business logic and validation
- Constructor injection of AlbumHasArtistRepository, AlbumRepository, ArtistRepository
- Relationship validation: ensures both Album and Artist exist before creating association
- Input validation for null/invalid IDs
- ID validation for all operations requiring entity lookup
- Comprehensive logging using Log4j2

Mapper Layer:
- AlbumHasArtistMapper for bidirectional entity/protobuf conversion
- Foreign key mapping for Album and Artist relationships
- Null safety checks and validation
- Proper handling of optional ID field

Action Handlers:
- CreateAlbumHasArtistHandler (albumhasartist.create)
- GetAlbumHasArtistHandler (albumhasartist.getAll)
- GetAlbumHasArtistByIdHandler (albumhasartist.getById)
- DeleteAlbumHasArtistHandler (albumhasartist.delete)
- HTTP status code handling: 200 (success), 400 (validation),
  404 (not found), 500 (server error)
- No update handler as join tables typically only require create/delete operations

Protocol Buffers:
- Complete proto definition with AlbumHasArtistMessages
- Messages support album_id and artist_id foreign keys
- CRUD message definitions (Create, Get, GetById, Delete)
- No Update messages as per join table requirements

Service Registration:
- AlbumHasArtistRepository initialized with EntityManagerFactory
- AlbumHasArtistService registered with ServiceLocator with required dependencies
- Ensures all AlbumHasArtist action handlers can resolve dependencies
- Proper dependency injection of AlbumRepository and ArtistRepository

The implementation follows best practices with proper error handling,
logging, validation, relationship integrity checks, and consistency with
existing codebase patterns. This enables proper many-to-many relationship
management between albums and artists.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

src/main/java/com/mediamanager/mapper/AlbumHasArtistMapper.java

@@ -0,0 +1,47 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+
+public class AlbumHasArtistMapper {
+    public static AlbumHasArtistMessages.AlbumHasArtist toProtobuf(AlbumHasArtist entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        AlbumHasArtistMessages.AlbumHasArtist.Builder builder = AlbumHasArtistMessages.AlbumHasArtist.newBuilder();
+
+        Integer id = entity.getId();
+        if (id != null) {
+            builder.setId(id);
+        }
+
+        // Map Album foreign key
+        if (entity.getAlbum() != null && entity.getAlbum().getId() != null) {
+            builder.setFkAlbumId(entity.getAlbum().getId());
+        }
+
+        // Map Artist foreign key
+        if (entity.getArtist() != null && entity.getArtist().getId() != null) {
+            builder.setFkArtistId(entity.getArtist().getId());
+        }
+
+        return builder.build();
+    }
+
+    public static AlbumHasArtist toEntity(AlbumHasArtistMessages.AlbumHasArtist protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        AlbumHasArtist entity = new AlbumHasArtist();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        // Note: Foreign key relationships (Album, Artist) are handled in the service layer
+
+        return entity;
+    }
+}

src/main/java/com/mediamanager/model/AlbumHasArtist.java

@@ -0,0 +1,56 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "albumshasartist")
+public class AlbumHasArtist {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_album_id", nullable = false)
+    private Album album;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "fk_artist_id", nullable = false)
+    private Artist artist;
+
+    public AlbumHasArtist() {}
+
+    // Getters and Setters
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Album getAlbum() {
+        return album;
+    }
+
+    public void setAlbum(Album album) {
+        this.album = album;
+    }
+
+    public Artist getArtist() {
+        return artist;
+    }
+
+    public void setArtist(Artist artist) {
+        this.artist = artist;
+    }
+
+    @Override
+    public String toString() {
+        return "AlbumHasArtist{" +
+                "id=" + id +
+                ", albumId=" + (album != null ? album.getId() : null) +
+                ", artistId=" + (artist != null ? artist.getId() : null) +
+                '}';
+    }
+}

src/main/java/com/mediamanager/repository/AlbumHasArtistRepository.java

@@ -0,0 +1,85 @@
+package com.mediamanager.repository;
+
+
+import com.mediamanager.model.AlbumHasArtist;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumHasArtistRepository {
+    private static final Logger logger = LogManager.getLogger(AlbumHasArtistRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public AlbumHasArtistRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public AlbumHasArtist save(AlbumHasArtist albumHasArtist) {
+        logger.debug("Saving AlbumHasArtist: {}", albumHasArtist);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(albumHasArtist);
+            em.getTransaction().commit();
+            logger.debug("AlbumHasArtist has been saved successfully");
+            return albumHasArtist;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while saving AlbumHasArtist: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<AlbumHasArtist> findAll() {
+        logger.debug("Finding All AlbumHasArtist");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            return em.createQuery("select a from AlbumHasArtist a", AlbumHasArtist.class).getResultList();
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<AlbumHasArtist> findById(Integer id) {
+        logger.debug("Finding AlbumHasArtist with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try{
+            AlbumHasArtist albumHasArtist = em.find(AlbumHasArtist.class, id);
+            return Optional.ofNullable(albumHasArtist);
+        }finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting AlbumHasArtist with id: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try{
+            AlbumHasArtist albumHasArtist = em.find(AlbumHasArtist.class, id);
+            if (albumHasArtist == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(albumHasArtist);
+            em.getTransaction().commit();
+            logger.debug("AlbumHasArtist has been deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error while deleting AlbumHasArtist: {}", e.getMessage());
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+}

src/main/java/com/mediamanager/service/albumhasartist/AlbumHasArtistService.java

@@ -0,0 +1,77 @@
+package com.mediamanager.service.albumhasartist;
+
+import com.mediamanager.model.Album;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.model.Artist;
+import com.mediamanager.repository.AlbumHasArtistRepository;
+import com.mediamanager.repository.AlbumRepository;
+import com.mediamanager.repository.ArtistRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class AlbumHasArtistService {
+    private static final Logger logger = LogManager.getLogger(AlbumHasArtistService.class);
+    private final AlbumHasArtistRepository repository;
+    private final AlbumRepository albumRepository;
+    private final ArtistRepository artistRepository;
+
+    public AlbumHasArtistService(AlbumHasArtistRepository repository, AlbumRepository albumRepository, ArtistRepository artistRepository) {
+        this.repository = repository;
+        this.albumRepository = albumRepository;
+        this.artistRepository = artistRepository;
+    }
+
+    public AlbumHasArtist createAlbumHasArtist(Integer albumId, Integer artistId) {
+        logger.debug("Creating album has artist relationship - albumId:{}, artistId:{}", albumId, artistId);
+
+        if (albumId == null || albumId <= 0) {
+            throw new IllegalArgumentException("Album ID cannot be null or invalid");
+        }
+        if (artistId == null || artistId <= 0) {
+            throw new IllegalArgumentException("Artist ID cannot be null or invalid");
+        }
+
+        // Verify Album exists
+        Optional<Album> album = albumRepository.findById(albumId);
+        if (album.isEmpty()) {
+            throw new IllegalArgumentException("Album not found with id: " + albumId);
+        }
+
+        // Verify Artist exists
+        Optional<Artist> artist = artistRepository.findById(artistId);
+        if (artist.isEmpty()) {
+            throw new IllegalArgumentException("Artist not found with id: " + artistId);
+        }
+
+        AlbumHasArtist albumHasArtist = new AlbumHasArtist();
+        albumHasArtist.setAlbum(album.get());
+        albumHasArtist.setArtist(artist.get());
+
+        return repository.save(albumHasArtist);
+    }
+
+    public List<AlbumHasArtist> getAllAlbumHasArtists() {
+        logger.info("Getting all album has artist relationships");
+        return repository.findAll();
+    }
+
+    public Optional<AlbumHasArtist> getAlbumHasArtistById(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID cannot be null");
+        }
+        logger.info("Getting album has artist by id:{}", id);
+        return repository.findById(id);
+    }
+
+    public boolean deleteAlbumHasArtist(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("Album has artist id cannot be null");
+        }
+        logger.info("Deleting album has artist:{}", id);
+        return repository.deleteById(id);
+    }
+
+}

src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java

@@ -5,6 +5,7 @@ import com.mediamanager.protocol.TransportProtocol;
 import com.mediamanager.repository.*;
 import com.mediamanager.service.album.AlbumService;
 import com.mediamanager.service.albumart.AlbumArtService;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
 import com.mediamanager.service.albumtype.AlbumTypeService;
 import com.mediamanager.service.bitdepth.BitDepthService;
 import com.mediamanager.service.bitrate.BitRateService;
@@ -90,6 +91,10 @@ public class DelegateActionManager {
         AlbumService albumService = new AlbumService(albumRepository, albumTypeRepository, albumArtRepository);
         serviceLocator.register(AlbumService.class, albumService);
 
+        AlbumHasArtistRepository albumHasArtistRepository = new AlbumHasArtistRepository(entityManagerFactory);
+        AlbumHasArtistService albumHasArtistService = new AlbumHasArtistService(albumHasArtistRepository, albumRepository, artistRepository);
+        serviceLocator.register(AlbumHasArtistService.class, albumHasArtistService);
+
         serviceLocator.logRegisteredServices();
 
         logger.info("Services initialized successfully");

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/CreateAlbumHasArtistHandler.java

@@ -0,0 +1,54 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasArtistMapper;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumhasartist.create")
+public class CreateAlbumHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateAlbumHasArtistHandler.class);
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public CreateAlbumHasArtistHandler(AlbumHasArtistService albumHasArtistService) {
+        this.albumHasArtistService = albumHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            AlbumHasArtistMessages.CreateAlbumHasArtistRequest createRequest =
+                    AlbumHasArtistMessages.CreateAlbumHasArtistRequest.parseFrom(requestPayload);
+
+            AlbumHasArtist albumHasArtist = albumHasArtistService.createAlbumHasArtist(
+                    createRequest.getFkAlbumId() > 0 ? createRequest.getFkAlbumId() : null,
+                    createRequest.getFkArtistId() > 0 ? createRequest.getFkArtistId() : null
+            );
+
+            AlbumHasArtistMessages.AlbumHasArtist albumHasArtistProto = AlbumHasArtistMapper.toProtobuf(albumHasArtist);
+            AlbumHasArtistMessages.CreateAlbumHasArtistResponse createAlbumHasArtistResponse = AlbumHasArtistMessages.CreateAlbumHasArtistResponse.newBuilder()
+                    .setAlbumhasartist(albumHasArtistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createAlbumHasArtistResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating album has artist", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/DeleteAlbumHasArtistHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("albumhasartist.delete")
+public class DeleteAlbumHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteAlbumHasArtistHandler.class);
+
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public DeleteAlbumHasArtistHandler(AlbumHasArtistService albumHasArtistService) {
+        this.albumHasArtistService = albumHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            AlbumHasArtistMessages.DeleteAlbumHasArtistRequest deleteRequest =
+                    AlbumHasArtistMessages.DeleteAlbumHasArtistRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = albumHasArtistService.deleteAlbumHasArtist(id);
+            AlbumHasArtistMessages.DeleteAlbumHasArtistResponse deleteResponse;
+            if (success) {
+                deleteResponse = AlbumHasArtistMessages.DeleteAlbumHasArtistResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Album has artist deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = AlbumHasArtistMessages.DeleteAlbumHasArtistResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Album has artist not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting album has artist", e);
+            AlbumHasArtistMessages.DeleteAlbumHasArtistResponse deleteResponse =
+                    AlbumHasArtistMessages.DeleteAlbumHasArtistResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/GetAlbumHasArtistByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasArtistMapper;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "albumhasartist.getById")
+public class GetAlbumHasArtistByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumHasArtistByIdHandler.class);
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public GetAlbumHasArtistByIdHandler(AlbumHasArtistService albumHasArtistService) {
+        this.albumHasArtistService = albumHasArtistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            AlbumHasArtistMessages.GetAlbumHasArtistByIdRequest getByIdRequest =
+                    AlbumHasArtistMessages.GetAlbumHasArtistByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<AlbumHasArtist> albumHasArtistOpt = albumHasArtistService.getAlbumHasArtistById(id);
+
+            if (albumHasArtistOpt.isEmpty()){
+                logger.warn("AlbumHasArtist not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("AlbumHasArtist not found"));
+            }
+            AlbumHasArtistMessages.AlbumHasArtist albumHasArtistProto = AlbumHasArtistMapper.toProtobuf(albumHasArtistOpt.get());
+            AlbumHasArtistMessages.GetAlbumHasArtistByIdResponse getByIdResponse = AlbumHasArtistMessages.GetAlbumHasArtistByIdResponse.newBuilder()
+                    .setAlbumhasartist(albumHasArtistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting album has artist by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/albumhasartist/GetAlbumHasArtistHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.albumhasartist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.AlbumHasArtistMapper;
+import com.mediamanager.model.AlbumHasArtist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.AlbumHasArtistMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.albumhasartist.AlbumHasArtistService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("albumhasartist.getAll")
+public class GetAlbumHasArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetAlbumHasArtistHandler.class);
+
+    private final AlbumHasArtistService albumHasArtistService;
+
+    public GetAlbumHasArtistHandler(AlbumHasArtistService albumHasArtistService){this.albumHasArtistService = albumHasArtistService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<AlbumHasArtist> albumHasArtists = albumHasArtistService.getAllAlbumHasArtists();
+            AlbumHasArtistMessages.GetAlbumHasArtistsResponse.Builder responseBuilder = AlbumHasArtistMessages.GetAlbumHasArtistsResponse.newBuilder();
+
+            for (AlbumHasArtist albumHasArtist : albumHasArtists) {
+                AlbumHasArtistMessages.AlbumHasArtist albumHasArtistProto = AlbumHasArtistMapper.toProtobuf(albumHasArtist);
+                responseBuilder.addAlbumhasartist(albumHasArtistProto);
+            }
+            AlbumHasArtistMessages.GetAlbumHasArtistsResponse getAlbumHasArtistsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getAlbumHasArtistsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting album has artists", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/proto/albumhasartist.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+option java_package = "com.mediamanager.protocol.messages";
+option java_outer_classname = "AlbumHasArtistMessages";
+
+package mediamanager.messages;
+
+message AlbumHasArtist {
+  int32 id = 1;
+  int32 fk_album_id = 2;
+  int32 fk_artist_id = 3;
+}
+
+message CreateAlbumHasArtistRequest {
+  int32 fk_album_id = 1;
+  int32 fk_artist_id = 2;
+}
+
+message CreateAlbumHasArtistResponse {
+  AlbumHasArtist albumhasartist = 1;
+}
+
+message GetAlbumHasArtistsRequest {
+
+}
+
+message GetAlbumHasArtistsResponse {
+  repeated AlbumHasArtist albumhasartist = 1;
+}
+
+message GetAlbumHasArtistByIdRequest {
+  int32 id = 1;
+}
+
+message GetAlbumHasArtistByIdResponse {
+  AlbumHasArtist albumhasartist = 1;
+}
+
+message DeleteAlbumHasArtistRequest {
+  int32 id = 1;
+}
+
+message DeleteAlbumHasArtistResponse {
+  bool success = 1;
+  string message = 2;
+}