SpringDataJDBC対応

jig-core/src/main/java/org/dddjava/jig/application/InfrastructureQueryService.java

@@ -29,6 +29,6 @@ public OutputImplementations outputImplementations(JigRepository jigRepository)
     public DatasourceAngles datasourceAngles(JigRepository jigRepository) {
         var jigTypes = typesQueryService.jigTypes(jigRepository);
         var outputImplementations = outputImplementations(jigRepository);
-        return DatasourceAngles.from(outputImplementations, jigRepository.jigDataProvider().fetchMybatisStatements(), MethodRelations.from(jigTypes));
+        return DatasourceAngles.from(outputImplementations, jigRepository.jigDataProvider().fetchSqlStatements(), MethodRelations.from(jigTypes));
     }
 }

jig-core/src/main/java/org/dddjava/jig/domain/model/data/JigDataProvider.java

@@ -1,7 +1,7 @@
 package org.dddjava.jig.domain.model.data;
 
 import org.dddjava.jig.domain.model.data.enums.EnumModels;
-import org.dddjava.jig.domain.model.data.rdbaccess.MyBatisStatements;
+import org.dddjava.jig.domain.model.data.rdbaccess.SqlStatements;
 
 import java.util.List;
 
@@ -10,8 +10,8 @@ public interface JigDataProvider {
     static JigDataProvider none() {
         return new JigDataProvider() {
             @Override
-            public MyBatisStatements fetchMybatisStatements() {
-                return MyBatisStatements.empty();
+            public SqlStatements fetchSqlStatements() {
+                return SqlStatements.empty();
             }
 
             @Override
@@ -21,7 +21,7 @@ public EnumModels fetchEnumModels() {
         };
     }
 
-    MyBatisStatements fetchMybatisStatements();
+    SqlStatements fetchSqlStatements();
 
     EnumModels fetchEnumModels();
 }

jig-core/src/main/java/org/dddjava/jig/domain/model/data/rdbaccess/Query.java

@@ -5,30 +5,70 @@
 /**
  * クエリ
  */
-public record Query(String text) {
+public record Query(String rawText, String normalizedQuery) {
 
     public static final String UNSUPPORTED = "<<unsupported>>";
 
     public static Query from(@Nullable String text) {
         if (text == null) return unsupported();
-        return new Query(text);
+        var normalizedQuery = normalizeSql(text);
+        if (normalizedQuery.isEmpty()) return unsupported();
+        return new Query(text, normalizedQuery);
     }
 
     public static Query unsupported() {
-        return new Query(UNSUPPORTED);
+        return new Query(UNSUPPORTED, UNSUPPORTED);
     }
 
     @Override
-    public String text() {
-        if (UNSUPPORTED.equals(text)) {
+    public String rawText() {
+        if (UNSUPPORTED.equals(rawText)) {
             // 特殊値を返さないようにする
             // Queryのtextは外部から使用しないので例外でよい。これが発生したらバグ。
             throw new IllegalArgumentException("BUG!!");
         }
-        return text;
+        return rawText;
     }
 
     public boolean supported() {
-        return !UNSUPPORTED.equals(text);
+        return !UNSUPPORTED.equals(rawText);
+    }
+
+    @Override
+    public String normalizedQuery() {
+        if (UNSUPPORTED.equals(rawText)) {
+            // 特殊値を返さないようにする
+            // Queryのtextは外部から使用しないので例外でよい。これが発生したらバグ。
+            throw new IllegalArgumentException("BUG!!");
+        }
+        return normalizedQuery;
+    }
+
+    private static String normalizeSql(String query) {
+        String remaining = query;
+        while (true) {
+            String trimmed = remaining.stripLeading();
+            if (trimmed.startsWith("\uFEFF")) {
+                remaining = trimmed.substring(1);
+                continue;
+            }
+            if (trimmed.startsWith("--")) {
+                int newlineIndex = trimmed.indexOf('\n');
+                if (newlineIndex < 0) return "";
+                remaining = trimmed.substring(newlineIndex + 1);
+                continue;
+            }
+            if (trimmed.startsWith("/*")) {
+                int commentEndIndex = trimmed.indexOf("*/");
+                if (commentEndIndex < 0) return "";
+                remaining = trimmed.substring(commentEndIndex + 2);
+                continue;
+            }
+            if (trimmed.startsWith("(")) {
+                remaining = trimmed.substring(1);
+                continue;
+            }
+            return trimmed;
+        }
     }
 }

jig-core/src/main/java/org/dddjava/jig/domain/model/data/rdbaccess/MyBatisStatement.java → jig-core/src/main/java/org/dddjava/jig/domain/model/data/rdbaccess/SqlStatement.java

@@ -3,11 +3,11 @@
 /**
  * SQL
  */
-public record MyBatisStatement(MyBatisStatementId myBatisStatementId, Query query, SqlType sqlType) {
+public record SqlStatement(SqlStatementId sqlStatementId, Query query, SqlType sqlType) {
 
     public Tables tables() {
         if (query.supported()) {
-            Table table = sqlType.extractTable(query.text(), myBatisStatementId);
+            Table table = sqlType.extractTable(query.normalizedQuery(), sqlStatementId);
             return new Tables(table);
         }
         return new Tables(sqlType.unexpectedTable());

jig-core/src/main/java/org/dddjava/jig/domain/model/data/rdbaccess/SqlStatementId.java

@@ -0,0 +1,43 @@
+package org.dddjava.jig.domain.model.data.rdbaccess;
+
+import java.util.Objects;
+
+/**
+ * SQLステートメントID
+ *
+ * namespaceとidを.で連結したもの。
+ *
+ * TODO namespaceやidはMyBatisの用語なのでこの形のままとするかは一考の余地がある
+ */
+public record SqlStatementId(String value, String namespace, String id) {
+
+    public static SqlStatementId from(String value) {
+        var namespaceIdSeparateIndex = value.lastIndexOf('.');
+        if (namespaceIdSeparateIndex != -1) {
+            return new SqlStatementId(value, value.substring(0, namespaceIdSeparateIndex), value.substring(namespaceIdSeparateIndex + 1));
+        } else {
+            return new SqlStatementId(value, "<unknown namespace>", value);
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        SqlStatementId that = (SqlStatementId) o;
+        return Objects.equals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+
+    public String namespace() {
+        return namespace;
+    }
+
+    public String id() {
+        return id;
+    }
+}

jig-core/src/main/java/org/dddjava/jig/domain/model/data/rdbaccess/MyBatisStatements.java → jig-core/src/main/java/org/dddjava/jig/domain/model/data/rdbaccess/SqlStatements.java

@@ -8,34 +8,34 @@
 /**
  * SQL一覧
  */
-public record MyBatisStatements(List<MyBatisStatement> list) {
+public record SqlStatements(List<SqlStatement> list) {
 
-    public static MyBatisStatements empty() {
-        return new MyBatisStatements(Collections.emptyList());
+    public static SqlStatements empty() {
+        return new SqlStatements(Collections.emptyList());
     }
 
     private Tables tables(SqlType sqlType) {
         return list.stream()
-                .filter(myBatisStatement -> myBatisStatement.sqlType() == sqlType)
-                .map(MyBatisStatement::tables)
+                .filter(sqlStatement -> sqlStatement.sqlType() == sqlType)
+                .map(SqlStatement::tables)
                 .reduce(Tables::merge)
                 .orElse(Tables.nothing());
     }
 
-    public Optional<MyBatisStatement> findById(MyBatisStatementId myBatisStatementId) {
+    public Optional<SqlStatement> findById(SqlStatementId sqlStatementId) {
         return list.stream()
-                .filter(myBatisStatement -> myBatisStatement.myBatisStatementId().equals(myBatisStatementId))
+                .filter(sqlStatement -> sqlStatement.sqlStatementId().equals(sqlStatementId))
                 .findFirst();
     }
 
     /**
      * 引数のメソッドに関連するステートメントに絞り込む
      */
-    public MyBatisStatements filterRelationOn(Predicate<MyBatisStatement> myBatisStatementPredicate) {
-        List<MyBatisStatement> myBatisStatements = list.stream()
-                .filter(myBatisStatementPredicate)
+    public SqlStatements filterRelationOn(Predicate<SqlStatement> sqlStatementPredicate) {
+        List<SqlStatement> sqlStatements = list.stream()
+                .filter(sqlStatementPredicate)
                 .toList();
-        return new MyBatisStatements(myBatisStatements);
+        return new SqlStatements(sqlStatements);
     }
 
     public boolean isEmpty() {

jig-core/src/main/java/org/dddjava/jig/domain/model/data/rdbaccess/SqlType.java

@@ -4,6 +4,8 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.List;
+import java.util.Locale;
+import java.util.Optional;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Stream;
@@ -33,23 +35,33 @@ public enum SqlType {
      * 現在は1テーブルのみ対応
      * 複問い合わせやWITHなどは未対応
      */
-    public Table extractTable(String sql, MyBatisStatementId myBatisStatementId) {
+    public Table extractTable(String sql, SqlStatementId sqlStatementId) {
         for (Pattern pattern : patterns) {
             Matcher matcher = pattern.matcher(sql.replaceAll("\n", " "));
             if (matcher.matches()) {
                 return new Table(matcher.group(1));
             }
         }
 
-        logger.warn("{} {} を {} としてテーブル名が解析できませんでした。このMapper由来の解析結果はドキュメントに出力されません。" +
-                        "MyBatisの動的なSQLなどは完全に再現できません。JIGが認識しているSQL文=[{}]",
-                myBatisStatementId.namespace(),
-                myBatisStatementId.id(),
+        logger.warn("{} {} を {} としてテーブル名が解析できませんでした。テーブル名は「解析失敗」と表示されます。JIGが認識しているSQL文=[{}]",
+                sqlStatementId.namespace(),
+                sqlStatementId.id(),
                 this, sql);
         return unexpectedTable();
     }
 
     public Table unexpectedTable() {
         return new Table("（解析失敗）");
     }
+
+    public static Optional<SqlType> inferSqlTypeFromQuery(Query query) {
+        String normalizedQuery = query.normalizedQuery().toLowerCase(Locale.ROOT);
+        if (normalizedQuery.startsWith("insert")) return Optional.of(INSERT);
+        if (normalizedQuery.startsWith("select")) return Optional.of(SELECT);
+        if (normalizedQuery.startsWith("update")) return Optional.of(UPDATE);
+        if (normalizedQuery.startsWith("delete")) return Optional.of(DELETE);
+
+        logger.info("SQLの種類がQuery文字列 [{}] から判別できませんでした。", query.rawText());
+        return Optional.empty();
+    }
 }

jig-core/src/main/java/org/dddjava/jig/domain/model/information/outputs/OutputImplementations.java

@@ -1,8 +1,12 @@
 package org.dddjava.jig.domain.model.information.outputs;
 
 import org.dddjava.jig.domain.model.information.types.JigTypes;
+import org.dddjava.jig.domain.model.data.types.JavaTypeDeclarationKind;
 
 import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 import static java.util.stream.Collectors.collectingAndThen;
@@ -25,13 +29,29 @@ public Gateways repositoryMethods() {
     // FIXME これのテストがない
     public static OutputImplementations from(JigTypes jigTypes, OutputAdapters outputAdapters) {
         return outputAdapters.stream()
-                // output adapterの実装しているoutput portのgatewayを
-                .flatMap(outputAdapter -> outputAdapter.implementsPortStream(jigTypes)
+                // interfaceのRepository(Spring Data JDBCなど)は実装クラスが存在しないため、自身をoutput portとして扱う
+                .flatMap(outputAdapter -> outputPorts(outputAdapter, jigTypes)
                         .flatMap(outputPort -> outputPort.gatewayStream()
                                 // 実装しているinvocationが
                                 .flatMap(gateway -> outputAdapter.resolveInvocation(gateway).stream()
                                         .map(invocation -> new OutputImplementation(gateway, invocation, outputPort)))))
-                .collect(collectingAndThen(toList(), OutputImplementations::new));
+                .collect(collectingAndThen(toList(), outputImplementations ->
+                        new OutputImplementations(outputImplementations.stream()
+                                .collect(collectingAndThen(
+                                        java.util.stream.Collectors.toMap(
+                                                outputImplementation -> outputImplementation.outputPortGateway().jigMethodId().namespace()
+                                                        + "#" + outputImplementation.outputPortGateway().name(),
+                                                Function.identity(),
+                                                (existing, ignored) -> existing,
+                                                LinkedHashMap::new),
+                                        map -> List.copyOf(map.values()))))));
+    }
+
+    private static Stream<OutputPort> outputPorts(OutputAdapter outputAdapter, JigTypes jigTypes) {
+        if (outputAdapter.jigType().jigTypeHeader().javaTypeDeclarationKind() == JavaTypeDeclarationKind.INTERFACE) {
+            return Stream.of(new OutputPort(outputAdapter.jigType()));
+        }
+        return outputAdapter.implementsPortStream(jigTypes);
     }
 
     public Stream<OutputImplementation> stream() {