Add DeleteObject API Implementation

Author: G8XSU

app/src/main/java/org/vss/KVStore.java

@@ -8,5 +8,7 @@ public interface KVStore {
 
   PutObjectResponse put(PutObjectRequest request);
 
+  DeleteObjectResponse delete(DeleteObjectRequest request);
+
   ListKeyVersionsResponse listKeyVersions(ListKeyVersionsRequest request);
 }

app/src/main/java/org/vss/api/DeleteObjectApi.java

@@ -0,0 +1,34 @@
+package org.vss.api;
+
+import jakarta.inject.Inject;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import lombok.extern.slf4j.Slf4j;
+import org.vss.DeleteObjectRequest;
+import org.vss.DeleteObjectResponse;
+import org.vss.KVStore;
+
+@Path(VssApiEndpoint.DELETE_OBJECT)
+@Slf4j
+public class DeleteObjectApi extends AbstractVssApi {
+  @Inject
+  public DeleteObjectApi(KVStore kvstore) {
+    super(kvstore);
+  }
+
+  @POST
+  @Produces(MediaType.APPLICATION_OCTET_STREAM)
+  public Response execute(byte[] payload) {
+    try {
+      DeleteObjectRequest request = DeleteObjectRequest.parseFrom(payload);
+      DeleteObjectResponse response = kvStore.delete(request);
+      return toResponse(response);
+    } catch (Exception e) {
+      log.error("Exception in DeleteObjectApi: ", e);
+      return toErrorResponse(e);
+    }
+  }
+}

app/src/main/java/org/vss/api/VssApiEndpoint.java

@@ -3,5 +3,6 @@
 public class VssApiEndpoint {
   public static final String GET_OBJECT = "/getObject";
   public static final String PUT_OBJECTS = "/putObjects";
+  public static final String DELETE_OBJECT = "/deleteObject";
   public static final String LIST_KEY_VERSIONS = "/listKeyVersions";
 }

app/src/main/java/org/vss/impl/postgres/PostgresBackendImpl.java

@@ -11,6 +11,8 @@
 import org.jooq.Insert;
 import org.jooq.Query;
 import org.jooq.Update;
+import org.vss.DeleteObjectRequest;
+import org.vss.DeleteObjectResponse;
 import org.vss.GetObjectRequest;
 import org.vss.GetObjectResponse;
 import org.vss.KVStore;
@@ -140,6 +142,20 @@ private VssDbRecord buildVssRecord(String storeId, KeyValue kv) {
         .setVersion(kv.getVersion());
   }
 
+  @Override
+  public DeleteObjectResponse delete(DeleteObjectRequest request) {
+    String storeId = request.getStoreId();
+    VssDbRecord vssDbRecord = buildVssRecord(storeId, request.getKeyValue());
+
+    context.transaction((ctx) -> {
+      DSLContext dsl = ctx.dsl();
+      Query deleteObjectQuery = buildDeleteObjectQuery(dsl, vssDbRecord);
+      dsl.execute(deleteObjectQuery);
+    });
+
+    return DeleteObjectResponse.newBuilder().build();
+  }
+
   @Override
   public ListKeyVersionsResponse listKeyVersions(ListKeyVersionsRequest request) {
     String storeId = request.getStoreId();

app/src/test/java/org/vss/AbstractKVStoreIntegrationTest.java

@@ -165,6 +165,32 @@ void putAndDeleteShouldSucceedAsAtomicTransaction() {
     assertThat(getObject(KVStore.GLOBAL_VERSION_KEY).getVersion(), is(0L));
   }
 
+  @Test
+  void deleteShouldSucceedWhenItemExists() {
+    assertDoesNotThrow(() -> putObjects(null, List.of(kv("k1", "k1v1", 0))));
+    assertDoesNotThrow(() -> deleteObject(kv("k1", "", 1)));
+
+    KeyValue response = getObject("k1");
+    assertThat(response.getKey(), is("k1"));
+    assertTrue(response.getValue().isEmpty());
+  }
+
+  @Test
+  void deleteShouldSucceedWhenItemDoesNotExist() {
+    assertDoesNotThrow(() -> deleteObject(kv("non_existent_key", "", 0)));
+  }
+
+  @Test
+  void deleteShouldBeIdempotent() {
+    assertDoesNotThrow(() -> putObjects(null, List.of(kv("k1", "k1v1", 0))));
+    assertDoesNotThrow(() -> deleteObject(kv("k1", "", 1)));
+    assertDoesNotThrow(() -> deleteObject(kv("k1", "", 1)));
+
+    KeyValue response = getObject("k1");
+    assertThat(response.getKey(), is("k1"));
+    assertTrue(response.getValue().isEmpty());
+  }
+
   @Test
   void getShouldReturnEmptyResponseWhenKeyDoesNotExist() {
     KeyValue response = getObject("non_existent_key");
@@ -417,6 +443,12 @@ private void putAndDeleteObjects(@Nullable Long globalVersion, List<KeyValue> pu
     this.kvStore.put(putObjectRequestBuilder.build());
   }
 
+  private void deleteObject(KeyValue keyValue) {
+    DeleteObjectRequest request = DeleteObjectRequest.newBuilder()
+        .setStoreId(STORE_ID).setKeyValue(keyValue).build();
+    this.kvStore.delete(request);
+  }
+
   private ListKeyVersionsResponse list(@Nullable String nextPageToken, @Nullable Integer pageSize,
       @Nullable String keyPrefix) {
     ListKeyVersionsRequest.Builder listRequestBuilder = ListKeyVersionsRequest.newBuilder()

app/src/test/java/org/vss/api/DeleteObjectApiTest.java

@@ -0,0 +1,88 @@
+package org.vss.api;
+
+import com.google.protobuf.ByteString;
+import jakarta.ws.rs.core.Response;
+import java.nio.charset.StandardCharsets;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.vss.DeleteObjectRequest;
+import org.vss.DeleteObjectResponse;
+import org.vss.ErrorCode;
+import org.vss.ErrorResponse;
+import org.vss.KVStore;
+import org.vss.KeyValue;
+import org.vss.exception.ConflictException;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class DeleteObjectApiTest {
+  private DeleteObjectApi deleteObjectApi;
+  private KVStore mockKVStore;
+
+  private static String TEST_STORE_ID = "storeId";
+  private static String TEST_KEY = "key";
+  private static KeyValue TEST_KV = KeyValue.newBuilder().setKey(TEST_KEY).setValue(
+      ByteString.copyFrom("test_value", StandardCharsets.UTF_8)).build();
+
+  @BeforeEach
+  void setUp() {
+    mockKVStore = mock(KVStore.class);
+    deleteObjectApi = new DeleteObjectApi(mockKVStore);
+  }
+
+  @Test
+  void execute_ValidPayload_ReturnsResponse() {
+    DeleteObjectRequest expectedRequest =
+        DeleteObjectRequest.newBuilder().setStoreId(TEST_STORE_ID).setKeyValue(
+            KeyValue.newBuilder().setKey(TEST_KEY).setVersion(0)
+        ).build();
+    byte[] payload = expectedRequest.toByteArray();
+    DeleteObjectResponse mockResponse = DeleteObjectResponse.newBuilder().build();
+    when(mockKVStore.delete(expectedRequest)).thenReturn(mockResponse);
+
+    Response actualResponse = deleteObjectApi.execute(payload);
+
+    assertThat(actualResponse.getStatus(), is(Response.Status.OK.getStatusCode()));
+    assertThat(actualResponse.getEntity(), is(mockResponse.toByteArray()));
+    verify(mockKVStore).delete(expectedRequest);
+  }
+
+  @ParameterizedTest
+  @MethodSource("provideErrorTestCases")
+  void execute_InvalidPayload_ReturnsErrorResponse(Exception exception,
+      ErrorCode errorCode) {
+    DeleteObjectRequest expectedRequest =
+        DeleteObjectRequest.newBuilder().setStoreId(TEST_STORE_ID).setKeyValue(
+            KeyValue.newBuilder().setKey(TEST_KEY).setVersion(0)
+        ).build();
+    byte[] payload = expectedRequest.toByteArray();
+    when(mockKVStore.delete(any())).thenThrow(exception);
+
+    Response response = deleteObjectApi.execute(payload);
+
+    ErrorResponse expectedErrorResponse = ErrorResponse.newBuilder()
+        .setErrorCode(errorCode)
+        .setMessage("")
+        .build();
+    assertThat(response.getEntity(), is(expectedErrorResponse.toByteArray()));
+    assertThat(response.getStatus(), is(expectedErrorResponse.getErrorCode().getNumber()));
+    verify(mockKVStore).delete(expectedRequest);
+  }
+
+  private static Stream<Arguments> provideErrorTestCases() {
+    return Stream.of(
+        Arguments.of(new ConflictException(""), ErrorCode.CONFLICT_EXCEPTION),
+        Arguments.of(new IllegalArgumentException(""), ErrorCode.INVALID_REQUEST_EXCEPTION),
+        Arguments.of(new RuntimeException(""), ErrorCode.INTERNAL_SERVER_EXCEPTION)
+    );
+  }
+}