Switch to a new Ktlint Formatter (#705)

* Switch to new Ktlint plugin

* Add ktlintCheck to PR builds

* Run formatter

* Put ktlint version in libs toml

* Fix lint

* Use Zip4Java from libs.toml

server/src/main/kotlin/suwayomi/tachidesk/graphql/dataLoaders/CategoryDataLoader.kt

@@ -23,48 +23,56 @@ import suwayomi.tachidesk.server.JavalinSetup.future
 
 class CategoryDataLoader : KotlinDataLoader<Int, CategoryType> {
     override val dataLoaderName = "CategoryDataLoader"
-    override fun getDataLoader(): DataLoader<Int, CategoryType> = DataLoaderFactory.newDataLoader { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val categories = CategoryTable.select { CategoryTable.id inList ids }
-                    .map { CategoryType(it) }
-                    .associateBy { it.id }
-                ids.map { categories[it] }
+
+    override fun getDataLoader(): DataLoader<Int, CategoryType> =
+        DataLoaderFactory.newDataLoader { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val categories =
+                        CategoryTable.select { CategoryTable.id inList ids }
+                            .map { CategoryType(it) }
+                            .associateBy { it.id }
+                    ids.map { categories[it] }
+                }
             }
         }
-    }
 }
 
 class CategoryForIdsDataLoader : KotlinDataLoader<List<Int>, CategoryNodeList> {
     override val dataLoaderName = "CategoryForIdsDataLoader"
-    override fun getDataLoader(): DataLoader<List<Int>, CategoryNodeList> = DataLoaderFactory.newDataLoader { categoryIds ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val ids = categoryIds.flatten().distinct()
-                val categories = CategoryTable.select { CategoryTable.id inList ids }.map { CategoryType(it) }
-                categoryIds.map { categoryIds ->
-                    categories.filter { it.id in categoryIds }.toNodeList()
+
+    override fun getDataLoader(): DataLoader<List<Int>, CategoryNodeList> =
+        DataLoaderFactory.newDataLoader { categoryIds ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val ids = categoryIds.flatten().distinct()
+                    val categories = CategoryTable.select { CategoryTable.id inList ids }.map { CategoryType(it) }
+                    categoryIds.map { categoryIds ->
+                        categories.filter { it.id in categoryIds }.toNodeList()
+                    }
                 }
             }
         }
-    }
 }
 
 class CategoriesForMangaDataLoader : KotlinDataLoader<Int, CategoryNodeList> {
     override val dataLoaderName = "CategoriesForMangaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, CategoryNodeList> = DataLoaderFactory.newDataLoader<Int, CategoryNodeList> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val itemsByRef = CategoryMangaTable.innerJoin(CategoryTable)
-                    .select { CategoryMangaTable.manga inList ids }
-                    .map { Pair(it[CategoryMangaTable.manga].value, CategoryType(it)) }
-                    .groupBy { it.first }
-                    .mapValues { it.value.map { pair -> pair.second } }
-                ids.map { (itemsByRef[it] ?: emptyList()).toNodeList() }
+
+    override fun getDataLoader(): DataLoader<Int, CategoryNodeList> =
+        DataLoaderFactory.newDataLoader<Int, CategoryNodeList> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val itemsByRef =
+                        CategoryMangaTable.innerJoin(CategoryTable)
+                            .select { CategoryMangaTable.manga inList ids }
+                            .map { Pair(it[CategoryMangaTable.manga].value, CategoryType(it)) }
+                            .groupBy { it.first }
+                            .mapValues { it.value.map { pair -> pair.second } }
+                    ids.map { (itemsByRef[it] ?: emptyList()).toNodeList() }
+                }
             }
         }
-    }
 }

server/src/main/kotlin/suwayomi/tachidesk/graphql/dataLoaders/ChapterDataLoader.kt

@@ -25,82 +25,95 @@ import suwayomi.tachidesk.server.JavalinSetup.future
 
 class ChapterDataLoader : KotlinDataLoader<Int, ChapterType?> {
     override val dataLoaderName = "ChapterDataLoader"
-    override fun getDataLoader(): DataLoader<Int, ChapterType?> = DataLoaderFactory.newDataLoader<Int, ChapterType> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val chapters = ChapterTable.select { ChapterTable.id inList ids }
-                    .map { ChapterType(it) }
-                    .associateBy { it.id }
-                ids.map { chapters[it] }
+
+    override fun getDataLoader(): DataLoader<Int, ChapterType?> =
+        DataLoaderFactory.newDataLoader<Int, ChapterType> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val chapters =
+                        ChapterTable.select { ChapterTable.id inList ids }
+                            .map { ChapterType(it) }
+                            .associateBy { it.id }
+                    ids.map { chapters[it] }
+                }
             }
         }
-    }
 }
 
 class ChaptersForMangaDataLoader : KotlinDataLoader<Int, ChapterNodeList> {
     override val dataLoaderName = "ChaptersForMangaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, ChapterNodeList> = DataLoaderFactory.newDataLoader<Int, ChapterNodeList> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val chaptersByMangaId = ChapterTable.select { ChapterTable.manga inList ids }
-                    .map { ChapterType(it) }
-                    .groupBy { it.mangaId }
-                ids.map { (chaptersByMangaId[it] ?: emptyList()).toNodeList() }
+
+    override fun getDataLoader(): DataLoader<Int, ChapterNodeList> =
+        DataLoaderFactory.newDataLoader<Int, ChapterNodeList> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val chaptersByMangaId =
+                        ChapterTable.select { ChapterTable.manga inList ids }
+                            .map { ChapterType(it) }
+                            .groupBy { it.mangaId }
+                    ids.map { (chaptersByMangaId[it] ?: emptyList()).toNodeList() }
+                }
             }
         }
-    }
 }
 
 class DownloadedChapterCountForMangaDataLoader : KotlinDataLoader<Int, Int> {
     override val dataLoaderName = "DownloadedChapterCountForMangaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, Int> = DataLoaderFactory.newDataLoader<Int, Int> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val downloadedChapterCountByMangaId =
-                    ChapterTable
-                        .slice(ChapterTable.manga, ChapterTable.isDownloaded.count())
-                        .select { (ChapterTable.manga inList ids) and (ChapterTable.isDownloaded eq true) }
-                        .groupBy(ChapterTable.manga)
-                        .associate { it[ChapterTable.manga].value to it[ChapterTable.isDownloaded.count()] }
-                ids.map { downloadedChapterCountByMangaId[it]?.toInt() ?: 0 }
+
+    override fun getDataLoader(): DataLoader<Int, Int> =
+        DataLoaderFactory.newDataLoader<Int, Int> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val downloadedChapterCountByMangaId =
+                        ChapterTable
+                            .slice(ChapterTable.manga, ChapterTable.isDownloaded.count())
+                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isDownloaded eq true) }
+                            .groupBy(ChapterTable.manga)
+                            .associate { it[ChapterTable.manga].value to it[ChapterTable.isDownloaded.count()] }
+                    ids.map { downloadedChapterCountByMangaId[it]?.toInt() ?: 0 }
+                }
             }
         }
-    }
 }
 
 class UnreadChapterCountForMangaDataLoader : KotlinDataLoader<Int, Int> {
     override val dataLoaderName = "UnreadChapterCountForMangaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, Int> = DataLoaderFactory.newDataLoader<Int, Int> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val unreadChapterCountByMangaId =
-                    ChapterTable
-                        .slice(ChapterTable.manga, ChapterTable.isRead.count())
-                        .select { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq false) }
-                        .groupBy(ChapterTable.manga)
-                        .associate { it[ChapterTable.manga].value to it[ChapterTable.isRead.count()] }
-                ids.map { unreadChapterCountByMangaId[it]?.toInt() ?: 0 }
+
+    override fun getDataLoader(): DataLoader<Int, Int> =
+        DataLoaderFactory.newDataLoader<Int, Int> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val unreadChapterCountByMangaId =
+                        ChapterTable
+                            .slice(ChapterTable.manga, ChapterTable.isRead.count())
+                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq false) }
+                            .groupBy(ChapterTable.manga)
+                            .associate { it[ChapterTable.manga].value to it[ChapterTable.isRead.count()] }
+                    ids.map { unreadChapterCountByMangaId[it]?.toInt() ?: 0 }
+                }
             }
         }
-    }
 }
 
 class LastReadChapterForMangaDataLoader : KotlinDataLoader<Int, ChapterType?> {
     override val dataLoaderName = "LastReadChapterForMangaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, ChapterType?> = DataLoaderFactory.newDataLoader<Int, ChapterType?> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val lastReadChaptersByMangaId = ChapterTable
-                    .select { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq true) }
-                    .orderBy(ChapterTable.sourceOrder to SortOrder.DESC)
-                    .groupBy { it[ChapterTable.manga].value }
-                ids.map { id -> lastReadChaptersByMangaId[id]?.let { chapters -> ChapterType(chapters.first()) } }
+
+    override fun getDataLoader(): DataLoader<Int, ChapterType?> =
+        DataLoaderFactory.newDataLoader<Int, ChapterType?> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val lastReadChaptersByMangaId =
+                        ChapterTable
+                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq true) }
+                            .orderBy(ChapterTable.sourceOrder to SortOrder.DESC)
+                            .groupBy { it[ChapterTable.manga].value }
+                    ids.map { id -> lastReadChaptersByMangaId[id]?.let { chapters -> ChapterType(chapters.first()) } }
+                }
             }
         }
-    }
 }

server/src/main/kotlin/suwayomi/tachidesk/graphql/dataLoaders/ExtensionDataLoader.kt

@@ -21,43 +21,50 @@ import suwayomi.tachidesk.server.JavalinSetup.future
 
 class ExtensionDataLoader : KotlinDataLoader<String, ExtensionType?> {
     override val dataLoaderName = "ExtensionDataLoader"
-    override fun getDataLoader(): DataLoader<String, ExtensionType?> = DataLoaderFactory.newDataLoader { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val extensions = ExtensionTable.select { ExtensionTable.pkgName inList ids }
-                    .map { ExtensionType(it) }
-                    .associateBy { it.pkgName }
-                ids.map { extensions[it] }
+
+    override fun getDataLoader(): DataLoader<String, ExtensionType?> =
+        DataLoaderFactory.newDataLoader { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val extensions =
+                        ExtensionTable.select { ExtensionTable.pkgName inList ids }
+                            .map { ExtensionType(it) }
+                            .associateBy { it.pkgName }
+                    ids.map { extensions[it] }
+                }
             }
         }
-    }
 }
 
 class ExtensionForSourceDataLoader : KotlinDataLoader<Long, ExtensionType?> {
     override val dataLoaderName = "ExtensionForSourceDataLoader"
-    override fun getDataLoader(): DataLoader<Long, ExtensionType?> = DataLoaderFactory.newDataLoader { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val extensions = ExtensionTable.innerJoin(SourceTable)
-                    .select { SourceTable.id inList ids }
-                    .toList()
-                    .map { Triple(it[SourceTable.id].value, it[ExtensionTable.pkgName], it) }
-                    .let { triples ->
-                        val sources = buildMap {
-                            triples.forEach {
-                                if (!containsKey(it.second)) {
-                                    put(it.second, ExtensionType(it.third))
+
+    override fun getDataLoader(): DataLoader<Long, ExtensionType?> =
+        DataLoaderFactory.newDataLoader { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val extensions =
+                        ExtensionTable.innerJoin(SourceTable)
+                            .select { SourceTable.id inList ids }
+                            .toList()
+                            .map { Triple(it[SourceTable.id].value, it[ExtensionTable.pkgName], it) }
+                            .let { triples ->
+                                val sources =
+                                    buildMap {
+                                        triples.forEach {
+                                            if (!containsKey(it.second)) {
+                                                put(it.second, ExtensionType(it.third))
+                                            }
+                                        }
+                                    }
+                                triples.associate {
+                                    it.first to sources[it.second]
                                 }
                             }
-                        }
-                        triples.associate {
-                            it.first to sources[it.second]
-                        }
-                    }
-                ids.map { extensions[it] }
+                    ids.map { extensions[it] }
+                }
             }
         }
-    }
 }

server/src/main/kotlin/suwayomi/tachidesk/graphql/dataLoaders/MangaDataLoader.kt

@@ -24,76 +24,89 @@ import suwayomi.tachidesk.server.JavalinSetup.future
 
 class MangaDataLoader : KotlinDataLoader<Int, MangaType?> {
     override val dataLoaderName = "MangaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, MangaType?> = DataLoaderFactory.newDataLoader { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val manga = MangaTable.select { MangaTable.id inList ids }
-                    .map { MangaType(it) }
-                    .associateBy { it.id }
-                ids.map { manga[it] }
+
+    override fun getDataLoader(): DataLoader<Int, MangaType?> =
+        DataLoaderFactory.newDataLoader { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val manga =
+                        MangaTable.select { MangaTable.id inList ids }
+                            .map { MangaType(it) }
+                            .associateBy { it.id }
+                    ids.map { manga[it] }
+                }
             }
         }
-    }
 }
 
 class MangaForCategoryDataLoader : KotlinDataLoader<Int, MangaNodeList> {
     override val dataLoaderName = "MangaForCategoryDataLoader"
-    override fun getDataLoader(): DataLoader<Int, MangaNodeList> = DataLoaderFactory.newDataLoader<Int, MangaNodeList> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val itemsByRef = if (ids.contains(0)) {
-                    MangaTable
-                        .leftJoin(CategoryMangaTable)
-                        .select { MangaTable.inLibrary eq true }
-                        .andWhere { CategoryMangaTable.manga.isNull() }
-                        .map { MangaType(it) }
-                        .let {
-                            mapOf(0 to it)
-                        }
-                } else {
-                    emptyMap()
-                } + CategoryMangaTable.innerJoin(MangaTable)
-                    .select { CategoryMangaTable.category inList ids }
-                    .map { Pair(it[CategoryMangaTable.category].value, MangaType(it)) }
-                    .groupBy { it.first }
-                    .mapValues { it.value.map { pair -> pair.second } }
 
-                ids.map { (itemsByRef[it] ?: emptyList()).toNodeList() }
+    override fun getDataLoader(): DataLoader<Int, MangaNodeList> =
+        DataLoaderFactory.newDataLoader<Int, MangaNodeList> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val itemsByRef =
+                        if (ids.contains(0)) {
+                            MangaTable
+                                .leftJoin(CategoryMangaTable)
+                                .select { MangaTable.inLibrary eq true }
+                                .andWhere { CategoryMangaTable.manga.isNull() }
+                                .map { MangaType(it) }
+                                .let {
+                                    mapOf(0 to it)
+                                }
+                        } else {
+                            emptyMap()
+                        } +
+                            CategoryMangaTable.innerJoin(MangaTable)
+                                .select { CategoryMangaTable.category inList ids }
+                                .map { Pair(it[CategoryMangaTable.category].value, MangaType(it)) }
+                                .groupBy { it.first }
+                                .mapValues { it.value.map { pair -> pair.second } }
+
+                    ids.map { (itemsByRef[it] ?: emptyList()).toNodeList() }
+                }
             }
         }
-    }
 }
 
 class MangaForSourceDataLoader : KotlinDataLoader<Long, MangaNodeList> {
     override val dataLoaderName = "MangaForSourceDataLoader"
-    override fun getDataLoader(): DataLoader<Long, MangaNodeList> = DataLoaderFactory.newDataLoader<Long, MangaNodeList> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val mangaBySourceId = MangaTable.select { MangaTable.sourceReference inList ids }
-                    .map { MangaType(it) }
-                    .groupBy { it.sourceId }
-                ids.map { (mangaBySourceId[it] ?: emptyList()).toNodeList() }
+
+    override fun getDataLoader(): DataLoader<Long, MangaNodeList> =
+        DataLoaderFactory.newDataLoader<Long, MangaNodeList> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val mangaBySourceId =
+                        MangaTable.select { MangaTable.sourceReference inList ids }
+                            .map { MangaType(it) }
+                            .groupBy { it.sourceId }
+                    ids.map { (mangaBySourceId[it] ?: emptyList()).toNodeList() }
+                }
             }
         }
-    }
 }
 
 class MangaForIdsDataLoader : KotlinDataLoader<List<Int>, MangaNodeList> {
     override val dataLoaderName = "MangaForIdsDataLoader"
-    override fun getDataLoader(): DataLoader<List<Int>, MangaNodeList> = DataLoaderFactory.newDataLoader { mangaIds ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val ids = mangaIds.flatten().distinct()
-                val manga = MangaTable.select { MangaTable.id inList ids }
-                    .map { MangaType(it) }
-                mangaIds.map { mangaIds ->
-                    manga.filter { it.id in mangaIds }.toNodeList()
+
+    override fun getDataLoader(): DataLoader<List<Int>, MangaNodeList> =
+        DataLoaderFactory.newDataLoader { mangaIds ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val ids = mangaIds.flatten().distinct()
+                    val manga =
+                        MangaTable.select { MangaTable.id inList ids }
+                            .map { MangaType(it) }
+                    mangaIds.map { mangaIds ->
+                        manga.filter { it.id in mangaIds }.toNodeList()
+                    }
                 }
             }
         }
-    }
 }

server/src/main/kotlin/suwayomi/tachidesk/graphql/dataLoaders/MetaDataLoader.kt

@@ -19,60 +19,72 @@ import suwayomi.tachidesk.server.JavalinSetup.future
 
 class GlobalMetaDataLoader : KotlinDataLoader<String, GlobalMetaType?> {
     override val dataLoaderName = "GlobalMetaDataLoader"
-    override fun getDataLoader(): DataLoader<String, GlobalMetaType?> = DataLoaderFactory.newDataLoader<String, GlobalMetaType?> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val metasByRefId = GlobalMetaTable.select { GlobalMetaTable.key inList ids }
-                    .map { GlobalMetaType(it) }
-                    .associateBy { it.key }
-                ids.map { metasByRefId[it] }
+
+    override fun getDataLoader(): DataLoader<String, GlobalMetaType?> =
+        DataLoaderFactory.newDataLoader<String, GlobalMetaType?> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val metasByRefId =
+                        GlobalMetaTable.select { GlobalMetaTable.key inList ids }
+                            .map { GlobalMetaType(it) }
+                            .associateBy { it.key }
+                    ids.map { metasByRefId[it] }
+                }
             }
         }
-    }
 }
 
 class ChapterMetaDataLoader : KotlinDataLoader<Int, List<ChapterMetaType>> {
     override val dataLoaderName = "ChapterMetaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, List<ChapterMetaType>> = DataLoaderFactory.newDataLoader<Int, List<ChapterMetaType>> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val metasByRefId = ChapterMetaTable.select { ChapterMetaTable.ref inList ids }
-                    .map { ChapterMetaType(it) }
-                    .groupBy { it.chapterId }
-                ids.map { metasByRefId[it].orEmpty() }
+
+    override fun getDataLoader(): DataLoader<Int, List<ChapterMetaType>> =
+        DataLoaderFactory.newDataLoader<Int, List<ChapterMetaType>> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val metasByRefId =
+                        ChapterMetaTable.select { ChapterMetaTable.ref inList ids }
+                            .map { ChapterMetaType(it) }
+                            .groupBy { it.chapterId }
+                    ids.map { metasByRefId[it].orEmpty() }
+                }
             }
         }
-    }
 }
 
 class MangaMetaDataLoader : KotlinDataLoader<Int, List<MangaMetaType>> {
     override val dataLoaderName = "MangaMetaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, List<MangaMetaType>> = DataLoaderFactory.newDataLoader<Int, List<MangaMetaType>> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val metasByRefId = MangaMetaTable.select { MangaMetaTable.ref inList ids }
-                    .map { MangaMetaType(it) }
-                    .groupBy { it.mangaId }
-                ids.map { metasByRefId[it].orEmpty() }
+
+    override fun getDataLoader(): DataLoader<Int, List<MangaMetaType>> =
+        DataLoaderFactory.newDataLoader<Int, List<MangaMetaType>> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val metasByRefId =
+                        MangaMetaTable.select { MangaMetaTable.ref inList ids }
+                            .map { MangaMetaType(it) }
+                            .groupBy { it.mangaId }
+                    ids.map { metasByRefId[it].orEmpty() }
+                }
             }
         }
-    }
 }
 
 class CategoryMetaDataLoader : KotlinDataLoader<Int, List<CategoryMetaType>> {
     override val dataLoaderName = "CategoryMetaDataLoader"
-    override fun getDataLoader(): DataLoader<Int, List<CategoryMetaType>> = DataLoaderFactory.newDataLoader<Int, List<CategoryMetaType>> { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val metasByRefId = CategoryMetaTable.select { CategoryMetaTable.ref inList ids }
-                    .map { CategoryMetaType(it) }
-                    .groupBy { it.categoryId }
-                ids.map { metasByRefId[it].orEmpty() }
+
+    override fun getDataLoader(): DataLoader<Int, List<CategoryMetaType>> =
+        DataLoaderFactory.newDataLoader<Int, List<CategoryMetaType>> { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val metasByRefId =
+                        CategoryMetaTable.select { CategoryMetaTable.ref inList ids }
+                            .map { CategoryMetaType(it) }
+                            .groupBy { it.categoryId }
+                    ids.map { metasByRefId[it].orEmpty() }
+                }
             }
         }
-    }
 }

server/src/main/kotlin/suwayomi/tachidesk/graphql/dataLoaders/SourceDataLoader.kt

@@ -23,34 +23,40 @@ import suwayomi.tachidesk.server.JavalinSetup.future
 
 class SourceDataLoader : KotlinDataLoader<Long, SourceType?> {
     override val dataLoaderName = "SourceDataLoader"
-    override fun getDataLoader(): DataLoader<Long, SourceType?> = DataLoaderFactory.newDataLoader { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
-                val source = SourceTable.select { SourceTable.id inList ids }
-                    .mapNotNull { SourceType(it) }
-                    .associateBy { it.id }
-                ids.map { source[it] }
+
+    override fun getDataLoader(): DataLoader<Long, SourceType?> =
+        DataLoaderFactory.newDataLoader { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
+                    val source =
+                        SourceTable.select { SourceTable.id inList ids }
+                            .mapNotNull { SourceType(it) }
+                            .associateBy { it.id }
+                    ids.map { source[it] }
+                }
             }
         }
-    }
 }
 
 class SourcesForExtensionDataLoader : KotlinDataLoader<String, SourceNodeList> {
     override val dataLoaderName = "SourcesForExtensionDataLoader"
-    override fun getDataLoader(): DataLoader<String, SourceNodeList> = DataLoaderFactory.newDataLoader { ids ->
-        future {
-            transaction {
-                addLogger(Slf4jSqlDebugLogger)
 
-                val sourcesByExtensionPkg = SourceTable.innerJoin(ExtensionTable)
-                    .select { ExtensionTable.pkgName inList ids }
-                    .map { Pair(it[ExtensionTable.pkgName], SourceType(it)) }
-                    .groupBy { it.first }
-                    .mapValues { it.value.mapNotNull { pair -> pair.second } }
+    override fun getDataLoader(): DataLoader<String, SourceNodeList> =
+        DataLoaderFactory.newDataLoader { ids ->
+            future {
+                transaction {
+                    addLogger(Slf4jSqlDebugLogger)
 
-                ids.map { (sourcesByExtensionPkg[it] ?: emptyList()).toNodeList() }
+                    val sourcesByExtensionPkg =
+                        SourceTable.innerJoin(ExtensionTable)
+                            .select { ExtensionTable.pkgName inList ids }
+                            .map { Pair(it[ExtensionTable.pkgName], SourceType(it)) }
+                            .groupBy { it.first }
+                            .mapValues { it.value.mapNotNull { pair -> pair.second } }
+
+                    ids.map { (sourcesByExtensionPkg[it] ?: emptyList()).toNodeList() }
+                }
             }
         }
-    }
 }