Feature/update to exposed v0.57.0 (#1150)

* Update to exposed-migrations v3.5.0

* Update to kotlin-logging v7.0.0

* Update to exposed v0.46.0

* Update to exposed v0.47.0

* Update to exposed v0.55.0

* Update to exposed v0.56.0

* Update to exposed v0.57.0

AndroidCompat/Config/src/main/java/xyz/nulldev/ts/config/ConfigManager.kt

@@ -14,9 +14,9 @@ import com.typesafe.config.ConfigValue
 import com.typesafe.config.ConfigValueFactory
 import com.typesafe.config.parser.ConfigDocument
 import com.typesafe.config.parser.ConfigDocumentFactory
+import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import mu.KotlinLogging
 import java.io.File
 
 /**

AndroidCompat/Config/src/main/java/xyz/nulldev/ts/config/Logging.kt

@@ -15,7 +15,8 @@ import ch.qos.logback.core.rolling.RollingFileAppender
 import ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy
 import ch.qos.logback.core.util.FileSize
 import com.typesafe.config.Config
-import mu.KotlinLogging
+import io.github.oshai.kotlinlogging.DelegatingKLogger
+import io.github.oshai.kotlinlogging.KotlinLogging
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 
@@ -73,7 +74,7 @@ private fun createRollingFileAppender(
 }
 
 private fun getBaseLogger(): ch.qos.logback.classic.Logger =
-    (KotlinLogging.logger(Logger.ROOT_LOGGER_NAME).underlyingLogger as ch.qos.logback.classic.Logger)
+    ((KotlinLogging.logger(Logger.ROOT_LOGGER_NAME) as DelegatingKLogger<*>).underlyingLogger as ch.qos.logback.classic.Logger)
 
 private fun getLogger(name: String): ch.qos.logback.classic.Logger {
     val context = LoggerFactory.getILoggerFactory() as LoggerContext

AndroidCompat/src/main/java/xyz/nulldev/androidcompat/io/sharedprefs/JavaSharedPreferences.kt

@@ -14,11 +14,11 @@ import com.russhwolf.settings.Settings
 import com.russhwolf.settings.serialization.decodeValue
 import com.russhwolf.settings.serialization.decodeValueOrNull
 import com.russhwolf.settings.serialization.encodeValue
+import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.builtins.SetSerializer
 import kotlinx.serialization.builtins.serializer
-import mu.KotlinLogging
 import xyz.nulldev.androidcompat.util.SafePath
 import xyz.nulldev.ts.config.ApplicationRootDir
 import java.util.Properties

AndroidCompat/src/main/java/xyz/nulldev/androidcompat/service/ServiceSupport.kt

@@ -3,7 +3,7 @@ package xyz.nulldev.androidcompat.service
 import android.app.Service
 import android.content.Context
 import android.content.Intent
-import mu.KotlinLogging
+import io.github.oshai.kotlinlogging.KotlinLogging
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.concurrent.thread
 

gradle/libs.versions.toml

@@ -5,7 +5,7 @@ serialization = "1.7.3"
 okhttp = "5.0.0-alpha.14" # Major version is locked by Tachiyomi extensions
 javalin = "6.3.0"
 jackson = "2.18.2" # jackson version locked by javalin, ref: `io.javalin.core.util.OptionalDependency`
-exposed = "0.40.1"
+exposed = "0.57.0"
 dex2jar = "v64" # Stuck until https://github.com/ThexXTURBOXx/dex2jar/issues/27 is fixed
 polyglot = "24.1.1"
 settings = "1.3.0"
@@ -36,7 +36,7 @@ serialization-xml = { module = "io.github.pdvrieze.xmlutil:serialization-jvm", v
 # Logging
 slf4japi = "org.slf4j:slf4j-api:2.0.16"
 logback = "ch.qos.logback:logback-classic:1.5.12"
-kotlinlogging = "io.github.microutils:kotlin-logging:3.0.5"
+kotlinlogging = "io.github.oshai:kotlin-logging-jvm:7.0.0"
 
 # OkHttp
 okhttp-core = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
@@ -66,7 +66,7 @@ exposed-javatime = { module = "org.jetbrains.exposed:exposed-java-time", version
 h2 = "com.h2database:h2:1.4.200" # current database driver, can't update to h2 v2 without sql migration
 
 # Exposed Migrations
-exposed-migrations = "com.github.Suwayomi:exposed-migrations:3.2.0"
+exposed-migrations = "com.github.Suwayomi:exposed-migrations:3.5.0"
 
 # Dependency Injection
 koin-core = { module = "io.insert-koin:koin-core", version.ref = "koin" }

server/src/main/kotlin/eu/kanade/tachiyomi/network/NetworkHelper.kt

@@ -12,13 +12,13 @@ import eu.kanade.tachiyomi.network.interceptor.CloudflareInterceptor
 import eu.kanade.tachiyomi.network.interceptor.IgnoreGzipInterceptor
 import eu.kanade.tachiyomi.network.interceptor.UncaughtExceptionInterceptor
 import eu.kanade.tachiyomi.network.interceptor.UserAgentInterceptor
+import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
-import mu.KotlinLogging
 import okhttp3.Cache
 import okhttp3.OkHttpClient
 import okhttp3.brotli.BrotliInterceptor

server/src/main/kotlin/eu/kanade/tachiyomi/network/interceptor/CloudflareInterceptor.kt

@@ -4,6 +4,7 @@ import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.parseAs
+import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.map
@@ -15,7 +16,6 @@ import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import mu.KotlinLogging
 import okhttp3.Cookie
 import okhttp3.HttpUrl
 import okhttp3.Interceptor

server/src/main/kotlin/eu/kanade/tachiyomi/source/local/LocalSource.kt

@@ -26,19 +26,19 @@ import eu.kanade.tachiyomi.source.model.SManga
 import eu.kanade.tachiyomi.util.chapter.ChapterRecognition
 import eu.kanade.tachiyomi.util.lang.compareToCaseInsensitiveNaturalOrder
 import eu.kanade.tachiyomi.util.storage.EpubFile
+import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.decodeFromStream
-import mu.KotlinLogging
 import nl.adaptivity.xmlutil.ExperimentalXmlUtilApi
 import nl.adaptivity.xmlutil.core.KtXmlReader
 import nl.adaptivity.xmlutil.serialization.XML
 import org.apache.commons.compress.archivers.zip.ZipFile
 import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.insertAndGetId
-import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.registerCatalogueSource
 import suwayomi.tachidesk.manga.impl.util.storage.ImageUtil
@@ -444,7 +444,7 @@ class LocalSource(
 
         fun register() {
             transaction {
-                val sourceRecord = SourceTable.select { SourceTable.id eq ID }.firstOrNull()
+                val sourceRecord = SourceTable.selectAll().where { SourceTable.id eq ID }.firstOrNull()
 
                 if (sourceRecord == null) {
                     // must do this to avoid database integrity errors

server/src/main/kotlin/suwayomi/tachidesk/global/impl/GlobalMeta.kt

@@ -1,7 +1,6 @@
 package suwayomi.tachidesk.global.impl
 
 import org.jetbrains.exposed.sql.insert
-import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
@@ -22,7 +21,7 @@ object GlobalMeta {
         transaction {
             val meta =
                 transaction {
-                    GlobalMetaTable.select { GlobalMetaTable.key eq key }
+                    GlobalMetaTable.selectAll().where { GlobalMetaTable.key eq key }
                 }.firstOrNull()
 
             if (meta == null) {

server/src/main/kotlin/suwayomi/tachidesk/graphql/AsDataFetcherResult.kt

@@ -2,7 +2,7 @@ package suwayomi.tachidesk.graphql
 
 import com.expediagroup.graphql.server.extensions.toGraphQLError
 import graphql.execution.DataFetcherResult
-import mu.KotlinLogging
+import io.github.oshai.kotlinlogging.KotlinLogging
 
 val logger = KotlinLogging.logger { }
 

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

@@ -13,7 +13,7 @@ import org.dataloader.DataLoader
 import org.dataloader.DataLoaderFactory
 import org.jetbrains.exposed.sql.Slf4jSqlDebugLogger
 import org.jetbrains.exposed.sql.addLogger
-import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import suwayomi.tachidesk.graphql.types.CategoryNodeList
 import suwayomi.tachidesk.graphql.types.CategoryNodeList.Companion.toNodeList
@@ -32,7 +32,8 @@ class CategoryDataLoader : KotlinDataLoader<Int, CategoryType> {
                     addLogger(Slf4jSqlDebugLogger)
                     val categories =
                         CategoryTable
-                            .select { CategoryTable.id inList ids }
+                            .selectAll()
+                            .where { CategoryTable.id inList ids }
                             .map { CategoryType(it) }
                             .associateBy { it.id }
                     ids.map { categories[it] }
@@ -50,7 +51,7 @@ class CategoryForIdsDataLoader : KotlinDataLoader<List<Int>, CategoryNodeList> {
                 transaction {
                     addLogger(Slf4jSqlDebugLogger)
                     val ids = categoryIds.flatten().distinct()
-                    val categories = CategoryTable.select { CategoryTable.id inList ids }.map { CategoryType(it) }
+                    val categories = CategoryTable.selectAll().where { CategoryTable.id inList ids }.map { CategoryType(it) }
                     categoryIds.map { categoryIds ->
                         categories.filter { it.id in categoryIds }.toNodeList()
                     }
@@ -70,7 +71,8 @@ class CategoriesForMangaDataLoader : KotlinDataLoader<Int, CategoryNodeList> {
                     val itemsByRef =
                         CategoryMangaTable
                             .innerJoin(CategoryTable)
-                            .select { CategoryMangaTable.manga inList ids }
+                            .selectAll()
+                            .where { CategoryMangaTable.manga inList ids }
                             .map { Pair(it[CategoryMangaTable.manga].value, CategoryType(it)) }
                             .groupBy { it.first }
                             .mapValues { it.value.map { pair -> pair.second } }

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

@@ -16,7 +16,7 @@ import org.jetbrains.exposed.sql.SortOrder
 import org.jetbrains.exposed.sql.addLogger
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.count
-import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import suwayomi.tachidesk.graphql.types.ChapterNodeList
 import suwayomi.tachidesk.graphql.types.ChapterNodeList.Companion.toNodeList
@@ -34,7 +34,8 @@ class ChapterDataLoader : KotlinDataLoader<Int, ChapterType?> {
                     addLogger(Slf4jSqlDebugLogger)
                     val chapters =
                         ChapterTable
-                            .select { ChapterTable.id inList ids }
+                            .selectAll()
+                            .where { ChapterTable.id inList ids }
                             .map { ChapterType(it) }
                             .associateBy { it.id }
                     ids.map { chapters[it] }
@@ -53,7 +54,8 @@ class ChaptersForMangaDataLoader : KotlinDataLoader<Int, ChapterNodeList> {
                     addLogger(Slf4jSqlDebugLogger)
                     val chaptersByMangaId =
                         ChapterTable
-                            .select { ChapterTable.manga inList ids }
+                            .selectAll()
+                            .where { ChapterTable.manga inList ids }
                             .map { ChapterType(it) }
                             .groupBy { it.mangaId }
                     ids.map { (chaptersByMangaId[it] ?: emptyList()).toNodeList() }
@@ -72,9 +74,11 @@ class DownloadedChapterCountForMangaDataLoader : KotlinDataLoader<Int, Int> {
                     addLogger(Slf4jSqlDebugLogger)
                     val downloadedChapterCountByMangaId =
                         ChapterTable
-                            .slice(ChapterTable.manga, ChapterTable.isDownloaded.count())
-                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isDownloaded eq true) }
-                            .groupBy(ChapterTable.manga)
+                            .select(ChapterTable.manga, ChapterTable.isDownloaded.count())
+                            .where {
+                                (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 }
                 }
@@ -92,9 +96,11 @@ class UnreadChapterCountForMangaDataLoader : KotlinDataLoader<Int, Int> {
                     addLogger(Slf4jSqlDebugLogger)
                     val unreadChapterCountByMangaId =
                         ChapterTable
-                            .slice(ChapterTable.manga, ChapterTable.isRead.count())
-                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq false) }
-                            .groupBy(ChapterTable.manga)
+                            .select(ChapterTable.manga, ChapterTable.isRead.count())
+                            .where {
+                                (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 }
                 }
@@ -112,9 +118,11 @@ class BookmarkedChapterCountForMangaDataLoader : KotlinDataLoader<Int, Int> {
                     addLogger(Slf4jSqlDebugLogger)
                     val bookmarkedChapterCountByMangaId =
                         ChapterTable
-                            .slice(ChapterTable.manga, ChapterTable.isBookmarked.count())
-                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isBookmarked eq true) }
-                            .groupBy(ChapterTable.manga)
+                            .select(ChapterTable.manga, ChapterTable.isBookmarked.count())
+                            .where {
+                                (ChapterTable.manga inList ids) and
+                                    (ChapterTable.isBookmarked eq true)
+                            }.groupBy(ChapterTable.manga)
                             .associate { it[ChapterTable.manga].value to it[ChapterTable.isBookmarked.count()] }
                     ids.map { bookmarkedChapterCountByMangaId[it]?.toInt() ?: 0 }
                 }
@@ -132,9 +140,14 @@ class HasDuplicateChaptersForMangaDataLoader : KotlinDataLoader<Int, Boolean> {
                     addLogger(Slf4jSqlDebugLogger)
                     val duplicatedChapterCountByMangaId =
                         ChapterTable
-                            .slice(ChapterTable.manga, ChapterTable.chapter_number, ChapterTable.chapter_number.count())
-                            .select { (ChapterTable.manga inList ids) and (ChapterTable.chapter_number greaterEq 0f) }
-                            .groupBy(ChapterTable.manga, ChapterTable.chapter_number)
+                            .select(ChapterTable.manga, ChapterTable.chapter_number, ChapterTable.chapter_number.count())
+                            .where {
+                                (
+                                    ChapterTable.manga inList
+                                        ids
+                                ) and
+                                    (ChapterTable.chapter_number greaterEq 0f)
+                            }.groupBy(ChapterTable.manga, ChapterTable.chapter_number)
                             .having { ChapterTable.chapter_number.count() greater 1 }
                             .associate { it[ChapterTable.manga].value to it[ChapterTable.chapter_number.count()] }
 
@@ -154,7 +167,8 @@ class LastReadChapterForMangaDataLoader : KotlinDataLoader<Int, ChapterType?> {
                     addLogger(Slf4jSqlDebugLogger)
                     val lastReadChaptersByMangaId =
                         ChapterTable
-                            .select { (ChapterTable.manga inList ids) }
+                            .selectAll()
+                            .where { (ChapterTable.manga inList ids) }
                             .orderBy(ChapterTable.lastReadAt to SortOrder.DESC)
                             .groupBy { it[ChapterTable.manga].value }
                     ids.map { id -> lastReadChaptersByMangaId[id]?.let { chapters -> ChapterType(chapters.first()) } }
@@ -173,7 +187,8 @@ class LatestReadChapterForMangaDataLoader : KotlinDataLoader<Int, ChapterType?>
                     addLogger(Slf4jSqlDebugLogger)
                     val latestReadChaptersByMangaId =
                         ChapterTable
-                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq true) }
+                            .selectAll()
+                            .where { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq true) }
                             .orderBy(ChapterTable.sourceOrder to SortOrder.DESC)
                             .groupBy { it[ChapterTable.manga].value }
                     ids.map { id -> latestReadChaptersByMangaId[id]?.let { chapters -> ChapterType(chapters.first()) } }
@@ -192,7 +207,8 @@ class LatestFetchedChapterForMangaDataLoader : KotlinDataLoader<Int, ChapterType
                     addLogger(Slf4jSqlDebugLogger)
                     val latestFetchedChaptersByMangaId =
                         ChapterTable
-                            .select { (ChapterTable.manga inList ids) }
+                            .selectAll()
+                            .where { (ChapterTable.manga inList ids) }
                             .orderBy(ChapterTable.fetchedAt to SortOrder.DESC, ChapterTable.sourceOrder to SortOrder.DESC)
                             .groupBy { it[ChapterTable.manga].value }
                     ids.map { id -> latestFetchedChaptersByMangaId[id]?.let { chapters -> ChapterType(chapters.first()) } }
@@ -211,7 +227,8 @@ class LatestUploadedChapterForMangaDataLoader : KotlinDataLoader<Int, ChapterTyp
                     addLogger(Slf4jSqlDebugLogger)
                     val latestUploadedChaptersByMangaId =
                         ChapterTable
-                            .select { (ChapterTable.manga inList ids) }
+                            .selectAll()
+                            .where { (ChapterTable.manga inList ids) }
                             .orderBy(ChapterTable.date_upload to SortOrder.DESC, ChapterTable.sourceOrder to SortOrder.DESC)
                             .groupBy { it[ChapterTable.manga].value }
                     ids.map { id -> latestUploadedChaptersByMangaId[id]?.let { chapters -> ChapterType(chapters.first()) } }
@@ -230,7 +247,8 @@ class FirstUnreadChapterForMangaDataLoader : KotlinDataLoader<Int, ChapterType?>
                     addLogger(Slf4jSqlDebugLogger)
                     val firstUnreadChaptersByMangaId =
                         ChapterTable
-                            .select { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq false) }
+                            .selectAll()
+                            .where { (ChapterTable.manga inList ids) and (ChapterTable.isRead eq false) }
                             .orderBy(ChapterTable.sourceOrder to SortOrder.ASC)
                             .groupBy { it[ChapterTable.manga].value }
                     ids.map { id -> firstUnreadChaptersByMangaId[id]?.let { chapters -> ChapterType(chapters.first()) } }