feat:add databasir diff api

api/src/main/java/com/databasir/api/DocumentController.java

@@ -1,6 +1,7 @@
 package com.databasir.api;
 
 import com.databasir.common.JsonData;
+import com.databasir.core.diff.data.RootDiff;
 import com.databasir.core.domain.document.data.DatabaseDocumentResponse;
 import com.databasir.core.domain.document.data.DatabaseDocumentSimpleResponse;
 import com.databasir.core.domain.document.data.DatabaseDocumentVersionResponse;
@@ -39,6 +40,13 @@ public class DocumentController {
         return JsonData.ok();
     }
 
+    @GetMapping(Routes.Document.DIFF)
+    public JsonData<RootDiff> diff(@PathVariable Integer projectId,
+                                   @RequestParam(name = "originalVersion") Long originalVersion,
+                                   @RequestParam(required = false) Long currentVersion) {
+        return JsonData.ok(documentService.diff(projectId, originalVersion, currentVersion));
+    }
+
     @GetMapping(Routes.Document.GET_ONE)
     public JsonData<DatabaseDocumentResponse> getByProjectId(@PathVariable Integer projectId,
                                                              @RequestParam(required = false) Long version) {

api/src/main/java/com/databasir/api/Routes.java

@@ -82,6 +82,8 @@ public interface Routes {
 
         String GET_TABLE_DETAIL = BASE + "/projects/{projectId}/documents/{documentId}/table_documents";
 
+        String DIFF = BASE + "/projects/{projectId}/diff_documents";
+
         String EXPORT = BASE + "/projects/{projectId}/document_files";
     }
 

core/src/main/java/com/databasir/core/domain/DomainErrors.java

@@ -32,6 +32,7 @@ public enum DomainErrors implements DatabasirErrors {
     MUST_NOT_MODIFY_SYSTEM_DEFAULT_DATABASE_TYPE("A_10017", "禁止修改系统默认数据库类型"),
     DOWNLOAD_DRIVER_ERROR("A_10018", "驱动下载失败"),
     INVALID_DATABASE_TYPE_URL_PATTERN("A_10019", "不合法的 url pattern"),
+    DOCUMENT_VERSION_IS_INVALID("A_10020", "文档版本不合法"),
     ;
 
     private final String errCode;

core/src/main/java/com/databasir/core/domain/document/service/DocumentService.java

@@ -349,4 +349,20 @@ public class DocumentService {
                             .ifPresent(generator -> generator.generate(context, out));
                 });
     }
+
+    public RootDiff diff(Integer projectId, Long originalVersion, Long currentVersion) {
+        var original = databaseDocumentDao.selectOptionalByProjectIdAndVersion(projectId, originalVersion)
+                .orElseThrow(DomainErrors.DOCUMENT_VERSION_IS_INVALID::exception);
+        DatabaseDocumentPojo current;
+        if (currentVersion == null) {
+            current = databaseDocumentDao.selectNotArchivedByProjectId(projectId)
+                    .orElseThrow(DomainErrors.DOCUMENT_VERSION_IS_INVALID::exception);
+        } else {
+            current = databaseDocumentDao.selectOptionalByProjectIdAndVersion(projectId, currentVersion)
+                    .orElseThrow(DomainErrors.DOCUMENT_VERSION_IS_INVALID::exception);
+        }
+        DatabaseMeta currMeta = retrieveOriginalDatabaseMeta(current);
+        DatabaseMeta originalMeta = retrieveOriginalDatabaseMeta(original);
+        return Diffs.diff(originalMeta, currMeta);
+    }
 }

plugin/src/main/java/com/databasir/core/diff/processor/TableDiffProcessor.java

@@ -19,18 +19,26 @@ public class TableDiffProcessor implements DiffProcessor<TableMeta> {
 
     private final ForeignKeyDiffProcessor foreignKeyDiffProcessor = new ForeignKeyDiffProcessor();
 
+    private static final TableMeta EMPTY = new TableMeta();
+
     @Override
     public FieldDiff process(String fieldName, List<TableMeta> original, List<TableMeta> current) {
         // diff tables field
         Map<String, TableMeta> originalMap = toMap(original, TableMeta::getName);
         Map<String, TableMeta> currentMap = toMap(current, TableMeta::getName);
-        List<FieldDiff> tables = new ArrayList<>(32);
+        List<FieldDiff> tables = new ArrayList<>();
-        // removed
+        List<TableMeta> added = added(originalMap, currentMap);
-        List<FieldDiff> removedFields = originalRemovedField(originalMap, currentMap);
+        List<TableMeta> removed = removed(originalMap, currentMap);
-        tables.addAll(removedFields);
         // added
-        List<FieldDiff> addedFields = currentAddedField(originalMap, currentMap);
+        List<FieldDiff> addedFields = added.stream()
+                .map(table -> diffTableField(EMPTY, table))
+                .collect(Collectors.toList());
         tables.addAll(addedFields);
+        // removed
+        List<FieldDiff> removedFields = removed.stream()
+                .map(table -> diffTableField(table, EMPTY))
+                .collect(Collectors.toList());
+        tables.addAll(removedFields);
         // modified
         List<FieldDiff> modified = originalMap.entrySet()
                 .stream()
@@ -61,6 +69,24 @@ public class TableDiffProcessor implements DiffProcessor<TableMeta> {
         return tablesField;
     }
 
+    private List<TableMeta> added(Map<String, TableMeta> originalMap,
+                                  Map<String, TableMeta> currentMap) {
+        return currentMap.entrySet()
+                .stream()
+                .filter(entry -> !originalMap.containsKey(entry.getKey()))
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toList());
+    }
+
+    private List<TableMeta> removed(Map<String, TableMeta> originalMap,
+                                    Map<String, TableMeta> currentMap) {
+        return originalMap.entrySet()
+                .stream()
+                .filter(entry -> !currentMap.containsKey(entry.getKey()))
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toList());
+    }
+
     private FieldDiff diffTableField(TableMeta original, TableMeta current) {
         FieldDiff columns =
                 columnDiffProcessor.process("columns", original.getColumns(), current.getColumns());
@@ -78,9 +104,19 @@ public class TableDiffProcessor implements DiffProcessor<TableMeta> {
         fields.add(foreignKeys);
         fields.add(triggers);
         fields.addAll(otherFields);
+        DiffType diffType;
+        if (original == EMPTY) {
+            diffType = DiffType.ADDED;
+        } else if (current == EMPTY) {
+            diffType = DiffType.REMOVED;
+        } else {
+            diffType = DiffType.MODIFIED;
+        }
         return FieldDiff.builder()
-                .diffType(DiffType.MODIFIED)
+                .diffType(diffType)
-                .fieldName(original.getName())
+                .fieldName(original == EMPTY ? current.getName() : original.getName())
+                .original(current == EMPTY ? original : null)
+                .current(original == EMPTY ? current : null)
                 .fields(fields)
                 .build();
     }