jnosql-arangodb: implement GraphDatabaseManager

Author: rashtao

jnosql-arangodb/pom.xml

@@ -41,6 +41,11 @@
             <groupId>org.eclipse.jnosql.mapping</groupId>
             <artifactId>jnosql-mapping-key-value</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.eclipse.jnosql.mapping</groupId>
+            <artifactId>jnosql-mapping-graph</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>jnosql-database-commons</artifactId>

jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/ArangoDBCommunicationEdge.java

@@ -0,0 +1,25 @@
+/*
+ *
+ *  Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *   All rights reserved. This program and the accompanying materials
+ *   are made available under the terms of the Eclipse Public License v1.0
+ *   and Apache License v2.0 which accompanies this distribution.
+ *   The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ *   and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
+ *
+ *   You may elect to redistribute this code under either of these licenses.
+ *
+ *   Contributors:
+ *
+ *   Otavio Santana
+ *
+ */
+package org.eclipse.jnosql.databases.arangodb.communication;
+
+import org.eclipse.jnosql.communication.graph.CommunicationEdge;
+import org.eclipse.jnosql.communication.semistructured.CommunicationEntity;
+
+import java.util.Map;
+
+record ArangoDBCommunicationEdge(String id, CommunicationEntity source, CommunicationEntity target, String label, Map<String, Object> properties) implements CommunicationEdge {
+}

jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/ArangoDBDocumentManager.java

@@ -14,6 +14,7 @@
  */
 package org.eclipse.jnosql.databases.arangodb.communication;
 
+import org.eclipse.jnosql.communication.graph.GraphDatabaseManager;
 import org.eclipse.jnosql.communication.semistructured.CommunicationEntity;
 import org.eclipse.jnosql.communication.semistructured.DatabaseManager;
 
@@ -23,7 +24,7 @@
  * The ArangoDB implementation of {@link DatabaseManager}. This implementation does not support TTL methods in the context of
  * {@link DatabaseManager#insert(org.eclipse.jnosql.communication.semistructured.CommunicationEntity)}.
  */
-public interface ArangoDBDocumentManager extends DatabaseManager, ArangoDBAccessor {
+public interface ArangoDBDocumentManager extends DatabaseManager, GraphDatabaseManager, ArangoDBAccessor {
 
     /**
      * Executes an ArangoDB query using the ArangoDB Query Language (AQL).

jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/ArangoDBUtil.java

@@ -16,8 +16,10 @@
 package org.eclipse.jnosql.databases.arangodb.communication;
 
 
+import com.arangodb.ArangoCollection;
 import com.arangodb.ArangoDB;
-import com.arangodb.entity.CollectionEntity;
+import com.arangodb.entity.CollectionType;
+import com.arangodb.model.CollectionCreateOptions;
 import jakarta.json.Json;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonArrayBuilder;
@@ -67,14 +69,21 @@ static void checkDatabase(String database, ArangoDB arangoDB) {
         }
     }
 
-    public static void checkCollection(String bucketName, ArangoDB arangoDB, String namespace) {
-        checkDatabase(bucketName, arangoDB);
-        List<String> collections = arangoDB.db(bucketName)
-                .getCollections().stream()
-                .map(CollectionEntity::getName)
-                .toList();
-        if (!collections.contains(namespace)) {
-            arangoDB.db(bucketName).createCollection(namespace);
+    public static void checkCollection(String dbName, ArangoDB arangoDB, String collectionName) {
+        checkDatabase(dbName, arangoDB);
+        ArangoCollection collection = arangoDB.db(dbName).collection(collectionName);
+        if (!collection.exists()) {
+            collection.create();
+        }
+    }
+
+    public static void checkEdgeCollection(String dbName, ArangoDB arangoDB, String collectionName) {
+        checkDatabase(dbName, arangoDB);
+        ArangoCollection collection = arangoDB.db(dbName).collection(collectionName);
+        if (!collection.exists()) {
+            collection.create(new CollectionCreateOptions().type(CollectionType.EDGES));
+        } else if (collection.getInfo().getType() != CollectionType.EDGES) {
+            throw new IllegalStateException(String.format("The collection %s is not an edge collection", collectionName));
         }
     }
 

jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/communication/DefaultArangoDBDocumentManager.java

@@ -11,22 +11,25 @@
  *   Contributors:
  *
  *   Otavio Santana
+ *   Michele Rastelli
  */
 package org.eclipse.jnosql.databases.arangodb.communication;
 
 import com.arangodb.ArangoCursor;
 import com.arangodb.ArangoDB;
-import com.arangodb.entity.BaseDocument;
+import com.arangodb.ArangoDatabase;
 import com.arangodb.entity.DocumentCreateEntity;
 import com.arangodb.entity.DocumentUpdateEntity;
 import jakarta.json.JsonObject;
+import org.eclipse.jnosql.communication.graph.CommunicationEdge;
 import org.eclipse.jnosql.communication.semistructured.CommunicationEntity;
 import org.eclipse.jnosql.communication.semistructured.DeleteQuery;
 import org.eclipse.jnosql.communication.semistructured.Element;
 import org.eclipse.jnosql.communication.semistructured.SelectQuery;
 
 import java.time.Duration;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -45,28 +48,27 @@ class DefaultArangoDBDocumentManager implements ArangoDBDocumentManager {
     public static final String KEY = "_key";
     public static final String ID = "_id";
     public static final String REV = "_rev";
+    public static final String FROM = "_from";
+    public static final String TO = "_to";
 
-    private final String database;
-
-    private final ArangoDB arangoDB;
+    private final ArangoDatabase db;
 
     DefaultArangoDBDocumentManager(String database, ArangoDB arangoDB) {
-        this.database = database;
-        this.arangoDB = arangoDB;
+        db = arangoDB.db(database);
     }
 
     @Override
     public String name() {
-        return database;
+        return db.name();
     }
 
     @Override
-    public CommunicationEntity insert(CommunicationEntity entity)  {
+    public CommunicationEntity insert(CommunicationEntity entity) {
         requireNonNull(entity, "entity is required");
         String collectionName = entity.name();
         checkCollection(collectionName);
         JsonObject jsonObject = ArangoDBUtil.toJsonObject(entity);
-        DocumentCreateEntity<Void> arangoDocument = arangoDB.db(database)
+        DocumentCreateEntity<Void> arangoDocument = db
                 .collection(collectionName).insertDocument(jsonObject);
         updateEntity(entity, arangoDocument.getKey(), arangoDocument.getId(), arangoDocument.getRev());
         return entity;
@@ -77,22 +79,10 @@ public CommunicationEntity update(CommunicationEntity entity) {
         requireNonNull(entity, "entity is required");
         String collectionName = entity.name();
         checkCollection(collectionName);
-        Optional<String> keyElement = entity.find(KEY, String.class);
-        Optional<String> idElement = entity.find(ID, String.class);
-        if (keyElement.isEmpty() && idElement.isEmpty()) {
-            throw new IllegalArgumentException("To update an entity is necessary to have either " + KEY + " or " + ID);
-        }
-        var key = keyElement.orElseGet(() -> {
-            String id = idElement.orElseThrow();
-            var elements = id.split("/");
-            if (elements.length == 2) {
-                return elements[1];
-            } else {
-                return elements[0];
-            }
-        });
         JsonObject jsonObject = ArangoDBUtil.toJsonObject(entity);
-        DocumentUpdateEntity<Void> arangoDocument = arangoDB.db(database)
+        String key = extractKey(entity).orElseThrow(() ->
+                new IllegalArgumentException("To update an entity is necessary to have either " + KEY + " or " + ID));
+        DocumentUpdateEntity<Void> arangoDocument = db
                 .collection(collectionName).updateDocument(key, jsonObject);
         updateEntity(entity, arangoDocument.getKey(), arangoDocument.getId(), arangoDocument.getRev());
         return entity;
@@ -114,13 +104,12 @@ public void delete(DeleteQuery query) {
             checkCollection(query.name());
             if (query.condition().isEmpty()) {
                 AQLQueryResult delete = QueryAQLConverter.delete(query);
-                arangoDB.db(database).query(delete.query(), BaseDocument.class);
+                db.query(delete.query(), Void.class);
                 return;
             }
 
             AQLQueryResult delete = QueryAQLConverter.delete(query);
-            arangoDB.db(database).query(delete.query(), BaseDocument.class, delete.values(),
-                    null);
+            db.query(delete.query(), Void.class, delete.values(), null);
         } catch (com.arangodb.ArangoDBException exception) {
             if (ERROR_ARANGO_DATA_SOURCE_NOT_FOUND.equals(exception.getErrorNum())) {
                 LOGGER.log(Level.FINEST, exception, () -> "An error to run query, that is related to delete " +
@@ -137,7 +126,7 @@ public Stream<CommunicationEntity> select(SelectQuery query) throws NullPointerE
         checkCollection(query.name());
         AQLQueryResult result = QueryAQLConverter.select(query);
         LOGGER.finest("Executing AQL: " + result.query());
-        ArangoCursor<JsonObject> documents = arangoDB.db(database).query(result.query(),
+        ArangoCursor<JsonObject> documents = db.query(result.query(),
                 JsonObject.class,
                 result.values(), null);
 
@@ -149,7 +138,7 @@ public Stream<CommunicationEntity> select(SelectQuery query) throws NullPointerE
     public long count(String documentCollection) {
         requireNonNull(documentCollection, "document collection is required");
         String aql = "RETURN LENGTH(" + documentCollection + ")";
-        ArangoCursor<Object> query = arangoDB.db(database).query(aql, Object.class, emptyMap(), null);
+        ArangoCursor<Object> query = db.query(aql, Object.class, emptyMap(), null);
         return StreamSupport.stream(query.spliterator(), false).findFirst().map(Number.class::cast)
                 .map(Number::longValue).orElse(0L);
     }
@@ -159,7 +148,7 @@ public long count(String documentCollection) {
     public Stream<CommunicationEntity> aql(String query, Map<String, Object> params) throws NullPointerException {
         requireNonNull(query, "query is required");
         requireNonNull(params, "values is required");
-        ArangoCursor<JsonObject> result = arangoDB.db(database).query(query, JsonObject.class, params, null);
+        ArangoCursor<JsonObject> result = db.query(query, JsonObject.class, params, null);
         return StreamSupport.stream(result.spliterator(), false)
                 .map(ArangoDBUtil::toEntity);
     }
@@ -169,27 +158,30 @@ public <T> Stream<T> aql(String query, Map<String, Object> params, Class<T> type
         requireNonNull(query, "query is required");
         requireNonNull(params, "values is required");
         requireNonNull(type, "typeClass is required");
-        ArangoCursor<T> result = arangoDB.db(database).query(query, type, params, null);
+        ArangoCursor<T> result = db.query(query, type, params, null);
         return StreamSupport.stream(result.spliterator(), false);
     }
 
     @Override
     public <T> Stream<T> aql(String query, Class<T> type) {
         requireNonNull(query, "query is required");
         requireNonNull(type, "typeClass is required");
-        ArangoCursor<T> result = arangoDB.db(database).query(query, type, emptyMap(), null);
-        return StreamSupport.stream(result.spliterator(), false);
+        return db.query(query, type, emptyMap(), null).stream();
     }
 
 
     @Override
     public void close() {
-        arangoDB.shutdown();
+        db.arango().shutdown();
     }
 
 
     private void checkCollection(String collectionName) {
-        ArangoDBUtil.checkCollection(database, arangoDB, collectionName);
+        ArangoDBUtil.checkCollection(db.name(), db.arango(), collectionName);
+    }
+
+    private void checkEdgeCollection(String collectionName) {
+        ArangoDBUtil.checkEdgeCollection(db.name(), db.arango(), collectionName);
     }
 
     @Override
@@ -216,7 +208,7 @@ public Iterable<CommunicationEntity> insert(Iterable<CommunicationEntity> entiti
 
     @Override
     public ArangoDB getArangoDB() {
-        return arangoDB;
+        return db.arango();
     }
 
     private void updateEntity(CommunicationEntity entity, String key, String id, String rev) {
@@ -225,4 +217,72 @@ private void updateEntity(CommunicationEntity entity, String key, String id, Str
         entity.add(Element.of(REV, rev));
     }
 
+    @Override
+    public CommunicationEdge edge(CommunicationEntity source, String label, CommunicationEntity target, Map<String, Object> properties) {
+        requireNonNull(source, "Source entity is required");
+        requireNonNull(target, "Target entity is required");
+        requireNonNull(label, "Relationship type is required");
+        requireNonNull(properties, "Properties map is required");
+
+        checkCollection(source.name());
+        checkCollection(target.name());
+        checkEdgeCollection(label);
+
+        source = ensureEntityExists(source);
+        target = ensureEntityExists(target);
+
+        CommunicationEntity entity = CommunicationEntity.of(label);
+        entity.add(FROM, extractId(source));
+        entity.add(TO, extractId(target));
+        properties.forEach(entity::add);
+
+        JsonObject jsonObject = ArangoDBUtil.toJsonObject(entity);
+        String key = db.collection(label).insertDocument(jsonObject).getKey();
+        return new ArangoDBCommunicationEdge(key, source, target, label, properties);
+    }
+
+    private CommunicationEntity ensureEntityExists(CommunicationEntity entity) {
+        return extractKey(entity)
+                .filter(key -> db.collection(entity.name()).documentExists(key))
+                .map(id -> entity)
+                .orElseGet(() -> insert(entity));
+    }
+
+    @Override
+    public void remove(CommunicationEntity source, String label, CommunicationEntity target) {
+        throw new UnsupportedOperationException("TODO");
+    }
+
+    @Override
+    public <K> void deleteEdge(K id) {
+        throw new UnsupportedOperationException("TODO");
+    }
+
+    @Override
+    public <K> Optional<CommunicationEdge> findEdgeById(K id) {
+        throw new UnsupportedOperationException("TODO");
+    }
+
+    private Optional<String> extractId(CommunicationEntity entity) {
+        Objects.requireNonNull(entity, "entity is required");
+        Objects.requireNonNull(entity.name(), "entity name is required");
+        if (entity.name().isEmpty()) {
+            throw new IllegalArgumentException("entity name cannot be empty");
+        }
+        return extractKey(entity).map(key -> entity.name() + "/" + key);
+    }
+
+    private Optional<String> extractKey(CommunicationEntity entity) {
+        return entity.find(KEY, String.class).or(() ->
+                entity.find(ID, String.class)
+                        .map(id -> {
+                            var elements = id.split("/");
+                            if (elements.length == 2) {
+                                return elements[1];
+                            } else {
+                                return elements[0];
+                            }
+                        }));
+    }
+
 }

jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/mapping/ArangoDBTemplate.java

@@ -17,6 +17,7 @@
 
 
 import org.eclipse.jnosql.mapping.document.DocumentTemplate;
+import org.eclipse.jnosql.mapping.graph.GraphTemplate;
 
 import java.util.Map;
 import java.util.stream.Stream;
@@ -27,7 +28,7 @@
  *  This template allows executing AQL queries with named parameters and supports
  * result serialization either through Eclipse JNoSQL or directly via ArangoDB.
  */
-public interface ArangoDBTemplate extends DocumentTemplate {
+public interface ArangoDBTemplate extends DocumentTemplate, GraphTemplate {
 
     /**
      * Executes an ArangoDB query using the ArangoDB Query Language (AQL).