test: 失敗するテストを修正

簡易クライアントからフォローできるように

.github/workflows/master-publish-package.yaml

@@ -19,7 +19,7 @@ jobs:
 
       - name: Check diff
         id: check-diff
-        uses: actions/github-script@v3
+        uses: actions/github-script@v7
         with:
           result-encoding: 'json'
           script: |

.github/workflows/pull-request-merge-check.yml

@@ -29,6 +29,8 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.PAT }}
 
       - name: Gradle Wrapper Validation
         uses: gradle/actions/wrapper-validation@v4
@@ -46,7 +48,7 @@ jobs:
           gradle-home-cache-cleanup: true
 
       - name: Build
-        run: ./gradlew :hideout-core:classes
+        run: ./gradlew classes --no-daemon
 
   unit-test:
     name: Unit Test
@@ -55,6 +57,8 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.PAT }}
 
       - name: Set up JDK 21
         uses: actions/setup-java@v4
@@ -69,12 +73,12 @@ jobs:
           gradle-home-cache-cleanup: true
 
       - name: Unit Test
-        run: ./gradlew :hideout-core:koverXmlReport
+        run: ./hideout-core/gradlew :hideout-core:koverXmlReport
 
       - name: Add coverage report to PR
         if: always()
         id: kover
-        uses: madrapps/jacoco-report@v1.6.1
+        uses: madrapps/jacoco-report@v1.7.0
         with:
           paths: |
             ${{ github.workspace }}/hideout-core/build/reports/kover/report.xml
@@ -94,9 +98,14 @@ jobs:
     name: Lint
     needs: [ setup ]
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
+          token: '${{ secrets.PAT }}'
 
       - name: Set up JDK 21
         uses: actions/setup-java@v4
@@ -111,7 +120,7 @@ jobs:
           gradle-home-cache-cleanup: true
 
       - name: Build with Gradle
-        run: ./gradlew :hideout-core:detektMain
+        run: ./gradlew :hideout-core:detektMain :hideout-mastodon:detektMain
 
       - name: Auto Commit
         if: ${{ always() }}

.gitignore

@@ -48,3 +48,5 @@ out/
 /hideout-core/files/
 /hideout-core/.kotlin/sessions/
 /hideout-mastodon/.kotlin/sessions/
+/http-client.private.env.json
+/logs/

build.gradle.kts

@@ -48,12 +48,6 @@ repositories {
         }
     }
 }
-configurations {
-    all {
-        exclude("org.springframework.boot", "spring-boot-starter-logging")
-        exclude("ch.qos.logback", "logback-classic")
-    }
-}
 
 dependencies {
     implementation("dev.usbharu:hideout-core:0.0.1")

docker-compose.yml

@@ -8,4 +8,9 @@ services:
     environment:
       POSTGRES_USER: "postgres"
       POSTGRES_PASSWORD: "password"
-      POSTGRES_DB: "hideout"
+      POSTGRES_DB: "hideout"
+
+  mongodb:
+    image: mongo:7.0.14
+    ports:
+      - "27017:27017"

gradle.properties

@@ -1,4 +1,4 @@
 org.gradle.parallel=true
 org.gradle.configureondemand=true
 org.gradle.caching=true
-org.gradle.jvmargs=-Xmx4096m -XX:+HeapDumpOnOutOfMemoryError -XX:+UseParallelGC --add-opens=java.base/java.util.concurrent.locks=ALL-UNNAMED -XX:TieredStopAtLevel=1 -noverify
+org.gradle.jvmargs=-Xmx4096m -XX:+HeapDumpOnOutOfMemoryError -XX:+UseParallelGC --add-opens=java.base/java.util.concurrent.locks=ALL-UNNAMED

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

hideout-activitypub/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

hideout-core/build.gradle.kts

@@ -74,6 +74,7 @@ val os = org.gradle.nativeplatform.platform.internal
 
 dependencies {
     developmentOnly(libs.h2db)
+    developmentOnly("org.springframework.boot:spring-boot-devtools")
     detektPlugins(libs.detekt.formatting)
 
     implementation(libs.bundles.exposed)
@@ -81,15 +82,14 @@ dependencies {
     implementation(libs.bundles.ktor.client)
     implementation(libs.bundles.apache.tika)
     implementation(libs.bundles.openapi)
-//    implementation(libs.bundles.owl.producer)
-//    implementation(libs.bundles.owl.broker)
+    implementation(libs.bundles.owl.producer)
+    implementation(libs.bundles.owl.broker)
     implementation(libs.bundles.spring.boot.oauth2)
     implementation(libs.bundles.spring.boot.data.mongodb)
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-security")
     implementation("org.springframework.boot:spring-boot-starter-thymeleaf")
-    implementation("org.springframework.boot:spring-boot-starter-log4j2")
     implementation("org.springframework.boot:spring-boot-starter-validation")
     annotationProcessor("org.springframework:spring-context-indexer")
 
@@ -103,7 +103,7 @@ dependencies {
     implementation(libs.flyway.core)
     runtimeOnly(libs.flyway.postgresql)
 
-//    implementation("dev.usbharu:owl-common-serialize-jackson:0.0.1")
+    implementation(libs.owl.common.serialize.jackson)
 
     implementation(libs.javacv) {
         exclude(module = "opencv")
@@ -122,39 +122,46 @@ dependencies {
         implementation(variantOf(libs.javacv.ffmpeg) { classifier("linux-x86_64") })
     }
 
-    implementation("dev.usbharu:http-signature:1.0.0")
-    implementation("dev.usbharu:emoji-kt:2.0.0")
-
-
+    implementation(libs.http.signature)
+    implementation(libs.emoji.kt)
+    implementation(libs.logback.ecs.encoder)
 
     testImplementation("org.springframework.boot:spring-boot-starter-test")
     testImplementation(libs.kotlin.junit)
     testImplementation(libs.coroutines.test)
     testImplementation(libs.ktor.client.mock)
     testImplementation(libs.h2db)
-    testImplementation("org.mockito.kotlin:mockito-kotlin:5.4.0")
-    testImplementation("org.mockito:mockito-inline:5.2.0")
-    testImplementation("nl.jqno.equalsverifier:equalsverifier:3.16.1")
-    testImplementation("com.jparams:to-string-verifier:1.4.8")
-
+    testImplementation(libs.mockito.kotlin)
 }
 
 detekt {
     parallel = true
-    config = files("../detekt.yml")
+    config.setFrom(files("../detekt.yml"))
     buildUponDefaultConfig = true
     basePath = "${rootDir.absolutePath}/src/main/kotlin"
     autoCorrect = true
 }
 
-configurations.matching { it.name == "detekt" }.all {
-    resolutionStrategy.eachDependency {
-        if (requested.group == "org.jetbrains.kotlin") {
-            useVersion(io.gitlab.arturbosch.detekt.getSupportedKotlinVersion())
+configurations {
+    matching { it.name == "detekt" }.all {
+        resolutionStrategy.eachDependency {
+            if (requested.group == "org.jetbrains.kotlin") {
+                useVersion(io.gitlab.arturbosch.detekt.getSupportedKotlinVersion())
+            }
         }
     }
+    all {
+        exclude("org.apache.logging.log4j", "log4j-slf4j2-impl")
+    }
 }
 
+
+//tasks{
+//    bootRun {
+//        sourceResources(sourceSets.main.get())
+//    }
+//}
+
 tasks.withType<io.gitlab.arturbosch.detekt.Detekt> {
     exclude("**/generated/**")
     doFirst {
@@ -172,13 +179,6 @@ tasks.withType<io.gitlab.arturbosch.detekt.DetektCreateBaselineTask>().configure
     exclude("**/org/koin/ksp/generated/**", "**/generated/**")
 }
 
-configurations {
-    all {
-        exclude("org.springframework.boot", "spring-boot-starter-logging")
-        exclude("ch.qos.logback", "logback-classic")
-    }
-}
-
 project.gradle.taskGraph.whenReady {
     println(this.allTasks)
     this.allTasks.map { println(it.name) }

hideout-core/gradle.properties

@@ -17,6 +17,4 @@ kotlin.code.style=official
 org.gradle.parallel=true
 org.gradle.configureondemand=true
 org.gradle.caching=true
-org.gradle.jvmargs=-Xmx4096m -XX:+HeapDumpOnOutOfMemoryError -XX:+UseParallelGC
-org.gradle.configuration-cache=true
-org.gradle.configuration-cache.problems=warn
+org.gradle.jvmargs=-Xmx4096m -XX:+HeapDumpOnOutOfMemoryError -XX:+UseParallelGC

hideout-core/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

hideout-core/settings.gradle.kts

@@ -3,11 +3,15 @@ plugins {
 }
 rootProject.name = "hideout-core"
 
-includeBuild("../owl")
+//ローカルで変更した時、リリースまではアンコメント リリース後はコメントアウト
+//includeBuild("../owl")
 
 dependencyResolutionManagement {
     repositories {
         mavenCentral()
+        maven {
+            url = uri("https://git.usbharu.dev/api/packages/usbharu/maven")
+        }
     }
 
     versionCatalogs {

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/ActorDetail.kt

@@ -0,0 +1,38 @@
+package dev.usbharu.hideout.core.application.actor
+
+import dev.usbharu.hideout.core.domain.model.actor.Actor
+import java.net.URI
+
+data class ActorDetail(
+    val id: Long,
+    val name: String,
+    val screenName: String,
+    val host: String,
+    val remoteUrl: String?,
+    val locked: Boolean,
+    val description: String,
+    val postsCount: Int,
+    val iconUrl: URI?,
+    val bannerURL: URI?,
+    val followingCount: Int?,
+    val followersCount: Int?,
+) {
+    companion object {
+        fun of(actor: Actor, iconUrl: URI?, bannerURL: URI?): ActorDetail {
+            return ActorDetail(
+                id = actor.id.id,
+                name = actor.name.name,
+                screenName = actor.screenName.screenName,
+                host = actor.url.host,
+                remoteUrl = actor.url.toString(),
+                locked = actor.locked,
+                description = actor.description.description,
+                postsCount = actor.postsCount.postsCount,
+                iconUrl = iconUrl,
+                bannerURL = bannerURL,
+                followingCount = actor.followingCount?.relationshipCount,
+                followersCount = actor.followersCount?.relationshipCount,
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/GetActorDetail.kt

@@ -0,0 +1,8 @@
+package dev.usbharu.hideout.core.application.actor
+
+import dev.usbharu.hideout.core.domain.model.support.acct.Acct
+
+data class GetActorDetail(
+    val actorName: Acct? = null,
+    val id: Long? = null
+)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/GetActorDetailApplicationService.kt

@@ -0,0 +1,49 @@
+package dev.usbharu.hideout.core.application.actor
+
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.config.ApplicationConfig
+import dev.usbharu.hideout.core.domain.model.actor.ActorId
+import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
+import dev.usbharu.hideout.core.domain.model.media.MediaRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Component
+
+@Component
+class GetActorDetailApplicationService(
+    private val actorRepository: ActorRepository,
+    private val mediaRepository: MediaRepository,
+    private val applicationConfig: ApplicationConfig,
+    transaction: Transaction
+) :
+    AbstractApplicationService<GetActorDetail, ActorDetail>(
+        transaction,
+        logger
+    ) {
+    override suspend fun internalExecute(command: GetActorDetail, principal: Principal): ActorDetail {
+        val actor = if (command.id != null) {
+            actorRepository.findById(ActorId(command.id))
+                ?: throw IllegalArgumentException("Actor ${command.id} not found.")
+        } else if (command.actorName != null) {
+            val host = if (command.actorName.host.isEmpty()) {
+                applicationConfig.url.host
+            } else {
+                command.actorName.host
+            }
+            actorRepository.findByNameAndDomain(command.actorName.userpart, host)
+                ?: throw IllegalArgumentException("Actor ${command.actorName} not found.")
+        } else {
+            throw IllegalArgumentException("id and actorName are null.")
+        }
+
+        val iconUrl = actor.icon?.let { mediaRepository.findById(it)?.url }
+        val bannerUrl = actor.banner?.let { mediaRepository.findById(it)?.url }
+
+        return ActorDetail.of(actor, iconUrl, bannerUrl)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(GetActorDetailApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/MigrationLocalActorApplicationService.kt

@@ -22,7 +22,7 @@ import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationS
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
 import dev.usbharu.hideout.core.domain.service.actor.local.AccountMigrationCheck.*
 import dev.usbharu.hideout.core.domain.service.actor.local.LocalActorMigrationCheckDomainService
@@ -37,7 +37,7 @@ class MigrationLocalActorApplicationService(
     private val userDetailRepository: UserDetailRepository,
 ) : LocalUserAbstractApplicationService<MigrationLocalActor, Unit>(transaction, logger) {
 
-    override suspend fun internalExecute(command: MigrationLocalActor, principal: FromApi) {
+    override suspend fun internalExecute(command: MigrationLocalActor, principal: LocalUser) {
         if (command.from != principal.actorId.id) {
             throw PermissionDeniedException()
         }
@@ -58,13 +58,15 @@ class MigrationLocalActorApplicationService(
         if (canAccountMigration.canMigration) {
             fromActor.moveTo = toActorId
             actorRepository.save(fromActor)
-        } else when (canAccountMigration) {
-            is AlreadyMoved -> throw IllegalArgumentException(canAccountMigration.message)
-            is CanAccountMigration -> throw InternalServerException()
-            is CircularReferences -> throw IllegalArgumentException(canAccountMigration.message)
-            is SelfReferences -> throw IllegalArgumentException("Self references are not supported")
-            is AlsoKnownAsNotFound -> throw IllegalArgumentException(canAccountMigration.message)
-            is MigrationCoolDown -> throw IllegalArgumentException(canAccountMigration.message)
+        } else {
+            when (canAccountMigration) {
+                is AlreadyMoved -> throw IllegalArgumentException(canAccountMigration.message)
+                is CanAccountMigration -> throw InternalServerException()
+                is CircularReferences -> throw IllegalArgumentException(canAccountMigration.message)
+                is SelfReferences -> throw IllegalArgumentException("Self references are not supported")
+                is AlsoKnownAsNotFound -> throw IllegalArgumentException(canAccountMigration.message)
+                is MigrationCoolDown -> throw IllegalArgumentException(canAccountMigration.message)
+            }
         }
     }
 

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/StartDeleteLocalActorApplicationService.kt

@@ -21,7 +21,7 @@ import dev.usbharu.hideout.core.application.exception.PermissionDeniedException
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -30,7 +30,7 @@ class StartDeleteLocalActorApplicationService(
     transaction: Transaction,
     private val actorRepository: ActorRepository,
 ) : LocalUserAbstractApplicationService<DeleteLocalActor, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: DeleteLocalActor, principal: FromApi) {
+    override suspend fun internalExecute(command: DeleteLocalActor, principal: LocalUser) {
         if (command.actorId != principal.actorId) {
             throw PermissionDeniedException()
         }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/SuspendLocalActor.kt

@@ -0,0 +1,3 @@
+package dev.usbharu.hideout.core.application.actor
+
+data class SuspendLocalActor(val actorId: Long)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/SuspendLocalActorApplicationService.kt

@@ -16,22 +16,29 @@
 
 package dev.usbharu.hideout.core.application.actor
 
+import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
+import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
 @Service
 class SuspendLocalActorApplicationService(
-    private val transaction: Transaction,
+    transaction: Transaction,
     private val actorRepository: ActorRepository,
-) {
-    suspend fun suspend(actorId: Long, executor: ActorId) {
-        transaction.transaction {
-            val id = ActorId(actorId)
+) : LocalUserAbstractApplicationService<SuspendLocalActor, Unit>(transaction, logger) {
 
-            val actor = actorRepository.findById(id)!!
-            actor.suspend = true
-        }
+    override suspend fun internalExecute(command: SuspendLocalActor, principal: LocalUser) {
+        val id = ActorId(command.actorId)
+        val actor =
+            actorRepository.findById(id) ?: throw IllegalArgumentException("Actor ${command.actorId} not found.")
+        actor.suspend = true
+        actorRepository.save(actor)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(SuspendLocalActorApplicationService::class.java)
     }
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/UnsuspendLocalActor.kt

@@ -0,0 +1,3 @@
+package dev.usbharu.hideout.core.application.actor
+
+data class UnsuspendLocalActor(val actorId: Long)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/actor/UnsuspendLocalActorApplicationService.kt

@@ -16,21 +16,29 @@
 
 package dev.usbharu.hideout.core.application.actor
 
+import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
+import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
 @Service
 class UnsuspendLocalActorApplicationService(
-    private val transaction: Transaction,
+    transaction: Transaction,
     private val actorRepository: ActorRepository,
-) {
-    suspend fun unsuspend(actorId: Long, executor: Long) {
-        transaction.transaction {
-            val findById = actorRepository.findById(ActorId(actorId))!!
+) : LocalUserAbstractApplicationService<UnsuspendLocalActor, Unit>(transaction, logger) {
 
-            findById.suspend = false
-        }
+    override suspend fun internalExecute(command: UnsuspendLocalActor, principal: LocalUser) {
+        val findById = actorRepository.findById(ActorId(command.actorId))
+            ?: throw IllegalArgumentException("Actor ${command.actorId} not found.")
+
+        findById.suspend = false
+        actorRepository.save(findById)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UnsuspendLocalActorApplicationService::class.java)
     }
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/application/RegisterApplicationApplicationService.kt

@@ -91,7 +91,6 @@ class RegisterApplicationApplicationService(
         )
     }
 
-
     companion object {
         private val logger = LoggerFactory.getLogger(RegisterApplicationApplicationService::class.java)
     }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/RegisterHomeTimeline.kt

@@ -0,0 +1,5 @@
+package dev.usbharu.hideout.core.application.domainevent.subscribers
+
+data class RegisterHomeTimeline(
+    val userDetailId: Long
+)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/RegisterLocalUserSetHomeTimelineSubscriber.kt

@@ -0,0 +1,21 @@
+package dev.usbharu.hideout.core.application.domainevent.subscribers
+
+import dev.usbharu.hideout.core.domain.event.userdetail.UserDetailEvent
+import dev.usbharu.hideout.core.domain.event.userdetail.UserDetailEventBody
+import dev.usbharu.hideout.core.domain.model.support.principal.Anonymous
+import org.springframework.stereotype.Component
+
+@Component
+class RegisterLocalUserSetHomeTimelineSubscriber(
+    private val domainEventSubscriber: DomainEventSubscriber,
+    private val userRegisterHomeTimelineApplicationService: UserRegisterHomeTimelineApplicationService
+) : Subscriber {
+    override fun init() {
+        domainEventSubscriber.subscribe<UserDetailEventBody>(UserDetailEvent.CREATE.eventName) {
+            userRegisterHomeTimelineApplicationService.execute(
+                RegisterHomeTimeline(it.body.getUserDetail().id),
+                Anonymous
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/RegisterTimelineSetTimelineStoreSubscriber.kt

@@ -0,0 +1,21 @@
+package dev.usbharu.hideout.core.application.domainevent.subscribers
+
+import dev.usbharu.hideout.core.application.timeline.SetTimelineToTimelineStoreApplicationService
+import dev.usbharu.hideout.core.application.timeline.SetTimleineStore
+import dev.usbharu.hideout.core.domain.event.timeline.TimelineEvent
+import dev.usbharu.hideout.core.domain.event.timeline.TimelineEventBody
+import dev.usbharu.hideout.core.domain.model.support.principal.Anonymous
+import org.springframework.stereotype.Component
+
+@Component
+class RegisterTimelineSetTimelineStoreSubscriber(
+    private val domainEventSubscriber: DomainEventSubscriber,
+    private val setTimelineToTimelineStoreApplicationService: SetTimelineToTimelineStoreApplicationService
+) : Subscriber {
+
+    override fun init() {
+        domainEventSubscriber.subscribe<TimelineEventBody>(TimelineEvent.CREATE.eventName) {
+            setTimelineToTimelineStoreApplicationService.execute(SetTimleineStore(it.body.getTimelineId()), Anonymous)
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/Subscriber.kt

@@ -1,3 +1,5 @@
 package dev.usbharu.hideout.core.application.domainevent.subscribers
 
-interface Subscriber
+interface Subscriber {
+    fun init()
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/SubscriberRunner.kt

@@ -5,7 +5,8 @@ import org.springframework.boot.ApplicationRunner
 import org.springframework.stereotype.Component
 
 @Component
-class SubscriberRunner(subscribers: List<Subscriber>) : ApplicationRunner {
+class SubscriberRunner(private val subscribers: List<Subscriber>) : ApplicationRunner {
     override fun run(args: ApplicationArguments?) {
+        subscribers.forEach { it.init() }
     }
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/TimelinePostCreateSubscriber.kt

@@ -1,22 +1,20 @@
 package dev.usbharu.hideout.core.application.domainevent.subscribers
 
+import dev.usbharu.hideout.core.application.timeline.AddPost
+import dev.usbharu.hideout.core.application.timeline.TimelineAddPostApplicationService
 import dev.usbharu.hideout.core.domain.event.post.PostEvent
 import dev.usbharu.hideout.core.domain.event.post.PostEventBody
-import org.slf4j.LoggerFactory
+import dev.usbharu.hideout.core.domain.model.support.principal.Anonymous
 import org.springframework.stereotype.Component
 
 @Component
-class TimelinePostCreateSubscriber(domainEventSubscriber: DomainEventSubscriber) : Subscriber {
-    init {
+class TimelinePostCreateSubscriber(
+    private val timelineAddPostApplicationService: TimelineAddPostApplicationService,
+    private val domainEventSubscriber: DomainEventSubscriber,
+) : Subscriber {
+    override fun init() {
         domainEventSubscriber.subscribe<PostEventBody>(PostEvent.CREATE.eventName) {
-            val post = it.body.getPost()
-            val actor = it.body.getActor()
-
-            logger.info("New Post! : {}", post)
+            timelineAddPostApplicationService.execute(AddPost(it.body.getPostId()), Anonymous)
         }
     }
-
-    companion object {
-        private val logger = LoggerFactory.getLogger(TimelinePostCreateSubscriber::class.java)
-    }
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/TimelineRelationshipFollowSubscriber.kt

@@ -1,50 +1,45 @@
 package dev.usbharu.hideout.core.application.domainevent.subscribers
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.timeline.AddTimelineRelationship
 import dev.usbharu.hideout.core.application.timeline.UserAddTimelineRelationshipApplicationService
 import dev.usbharu.hideout.core.domain.event.relationship.RelationshipEvent
 import dev.usbharu.hideout.core.domain.event.relationship.RelationshipEventBody
-import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationship
-import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipId
 import dev.usbharu.hideout.core.domain.model.timelinerelationship.Visible
 import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
-import dev.usbharu.hideout.core.domain.shared.id.IdGenerateService
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
 @Component
 class TimelineRelationshipFollowSubscriber(
     private val userAddTimelineRelationshipApplicationService: UserAddTimelineRelationshipApplicationService,
-    private val idGenerateService: IdGenerateService,
     private val userDetailRepository: UserDetailRepository,
-    domainEventSubscriber: DomainEventSubscriber
+    private val domainEventSubscriber: DomainEventSubscriber
 ) : Subscriber {
 
-    init {
-        domainEventSubscriber.subscribe<RelationshipEventBody>(RelationshipEvent.FOLLOW.eventName) {
+    override fun init() {
+        domainEventSubscriber.subscribe<RelationshipEventBody>(RelationshipEvent.ACCEPT_FOLLOW.eventName) {
             val relationship = it.body.getRelationship()
-            val userDetail = userDetailRepository.findByActorId(relationship.actorId.id) ?: throw Exception()
+            val userDetail = userDetailRepository.findByActorId(relationship.actorId.id)
+                ?: throw InternalServerException("Userdetail ${relationship.actorId} not found by actorid.")
             if (userDetail.homeTimelineId == null) {
                 logger.warn("Home timeline for ${relationship.actorId} is not found")
                 return@subscribe
             }
+
+            @Suppress("UnsafeCallOnNullableType")
             userAddTimelineRelationshipApplicationService.execute(
                 AddTimelineRelationship(
-                    TimelineRelationship(
-                        TimelineRelationshipId(idGenerateService.generateId()),
-                        userDetail.homeTimelineId,
-                        relationship.targetActorId,
-                        Visible.FOLLOWERS
-                    )
-                ), it.body.principal
+                    userDetail.homeTimelineId!!,
+                    relationship.targetActorId,
+                    Visible.FOLLOWERS
+                ),
+                it.body.principal
             )
-
-
         }
     }
 
     companion object {
         private val logger = LoggerFactory.getLogger(TimelineRelationshipFollowSubscriber::class.java)
     }
-
-}
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/TimelineRelationshipUnfollowSubscriber.kt

@@ -0,0 +1,46 @@
+package dev.usbharu.hideout.core.application.domainevent.subscribers
+
+import dev.usbharu.hideout.core.application.timeline.RemoveTimelineRelationship
+import dev.usbharu.hideout.core.application.timeline.UserRemoveTimelineRelationshipApplicationService
+import dev.usbharu.hideout.core.domain.event.relationship.RelationshipEvent
+import dev.usbharu.hideout.core.domain.event.relationship.RelationshipEventBody
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipRepository
+import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Component
+
+@Component
+class TimelineRelationshipUnfollowSubscriber(
+    private val domainEventSubscriber: DomainEventSubscriber,
+    private val userRemoveTimelineRelationshipApplicationService: UserRemoveTimelineRelationshipApplicationService,
+    private val userDetailRepository: UserDetailRepository,
+    private val timelineRelationshipRepository: TimelineRelationshipRepository,
+) : Subscriber {
+    override fun init() {
+        domainEventSubscriber.subscribe<RelationshipEventBody>(RelationshipEvent.UNFOLLOW.eventName) {
+            val relationship = it.body.getRelationship()
+            val userDetail = userDetailRepository.findByActorId(relationship.actorId.id) ?: throw IllegalStateException(
+                "UserDetail ${relationship.actorId} not found by actorId."
+            )
+            if (userDetail.homeTimelineId == null) {
+                logger.warn("HomeTimeline for ${userDetail.id} not found.")
+                return@subscribe
+            }
+
+            val timelineRelationship = timelineRelationshipRepository.findByTimelineIdAndActorId(
+                userDetail.homeTimelineId!!,
+                relationship.targetActorId
+            )
+                ?: throw IllegalStateException("TimelineRelationship ${userDetail.homeTimelineId} to ${relationship.targetActorId} not found by timelineId and ActorId")
+
+            userRemoveTimelineRelationshipApplicationService.execute(
+                RemoveTimelineRelationship(timelineRelationship.id),
+                it.body.principal
+            )
+        }
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(TimelineRelationshipUnfollowSubscriber::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/domainevent/subscribers/UserRegisterHomeTimelineApplicationService.kt

@@ -0,0 +1,56 @@
+package dev.usbharu.hideout.core.application.domainevent.subscribers
+
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.domain.model.timeline.*
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationship
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipId
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipRepository
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.Visible
+import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailId
+import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.shared.id.IdGenerateService
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Component
+
+@Component
+class UserRegisterHomeTimelineApplicationService(
+    private val userDetailRepository: UserDetailRepository,
+    private val timelineRepository: TimelineRepository,
+    private val idGenerateService: IdGenerateService,
+    transaction: Transaction,
+    private val timelineRelationshipRepository: TimelineRelationshipRepository
+) : AbstractApplicationService<RegisterHomeTimeline, Unit>(transaction, logger) {
+    override suspend fun internalExecute(command: RegisterHomeTimeline, principal: Principal) {
+        val userDetail = (
+            userDetailRepository.findById(UserDetailId(command.userDetailId))
+                ?: throw IllegalArgumentException("UserDetail ${command.userDetailId} not found.")
+            )
+
+        val timeline = Timeline.create(
+            TimelineId(idGenerateService.generateId()),
+            UserDetailId(command.userDetailId),
+            TimelineName("System-LocalUser-HomeTimeline-${command.userDetailId}"),
+            TimelineVisibility.PRIVATE,
+            true
+        )
+        timelineRepository.save(timeline)
+        userDetail.homeTimelineId = timeline.id
+
+        val timelineRelationship = TimelineRelationship(
+            TimelineRelationshipId(idGenerateService.generateId()),
+            timeline.id,
+            userDetail.actorId,
+            Visible.DIRECT
+        )
+
+        timelineRelationshipRepository.save(timelineRelationship)
+
+        userDetailRepository.save(userDetail)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UserRegisterHomeTimelineApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/exception/InternalServerException.kt

@@ -11,4 +11,4 @@ class InternalServerException : RuntimeException {
         enableSuppression,
         writableStackTrace
     )
-}
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/exception/PermissionDeniedException.kt

@@ -11,4 +11,4 @@ class PermissionDeniedException : RuntimeException {
         enableSuppression,
         writableStackTrace
     )
-}
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/filter/UserDeleteFilterApplicationService.kt

@@ -21,7 +21,7 @@ import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationS
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.filter.FilterId
 import dev.usbharu.hideout.core.domain.model.filter.FilterRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -31,7 +31,7 @@ class UserDeleteFilterApplicationService(private val filterRepository: FilterRep
         transaction,
         logger
     ) {
-    override suspend fun internalExecute(command: DeleteFilter, principal: FromApi) {
+    override suspend fun internalExecute(command: DeleteFilter, principal: LocalUser) {
         val filter =
             filterRepository.findByFilterId(FilterId(command.filterId)) ?: throw IllegalArgumentException("not found")
         if (filter.userDetailId != principal.userDetailId) {

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/filter/UserGetFilterApplicationService.kt

@@ -21,7 +21,7 @@ import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationS
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.filter.FilterId
 import dev.usbharu.hideout.core.domain.model.filter.FilterRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -31,7 +31,7 @@ class UserGetFilterApplicationService(private val filterRepository: FilterReposi
         transaction,
         logger
     ) {
-    override suspend fun internalExecute(command: GetFilter, principal: FromApi): Filter {
+    override suspend fun internalExecute(command: GetFilter, principal: LocalUser): Filter {
         val filter =
             filterRepository.findByFilterId(FilterId(command.filterId)) ?: throw IllegalArgumentException("Not Found")
         if (filter.userDetailId != principal.userDetailId) {

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/filter/UserRegisterFilterApplicationService.kt

@@ -20,7 +20,7 @@ import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationS
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.filter.*
 import dev.usbharu.hideout.core.domain.model.filter.FilterKeyword
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import dev.usbharu.hideout.core.domain.shared.id.IdGenerateService
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
@@ -36,8 +36,7 @@ class UserRegisterFilterApplicationService(
         logger
     ) {
 
-    override suspend fun internalExecute(command: RegisterFilter, principal: FromApi): Filter {
-
+    override suspend fun internalExecute(command: RegisterFilter, principal: LocalUser): Filter {
         val filter = dev.usbharu.hideout.core.domain.model.filter.Filter.create(
             id = FilterId(idGenerateService.generateId()),
             userDetailId = principal.userDetailId,

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/instance/GetLocalInstanceApplicationService.kt

@@ -0,0 +1,44 @@
+package dev.usbharu.hideout.core.application.instance
+
+import dev.usbharu.hideout.core.application.exception.InternalServerException
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.config.ApplicationConfig
+import dev.usbharu.hideout.core.domain.model.instance.InstanceRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class GetLocalInstanceApplicationService(
+    private val applicationConfig: ApplicationConfig,
+    private val instanceRepository: InstanceRepository,
+    transaction: Transaction
+) :
+    AbstractApplicationService<Unit, Instance>(
+        transaction,
+        logger
+    ) {
+    private var cachedInstance: Instance? = null
+
+    override suspend fun internalExecute(command: Unit, principal: Principal): Instance {
+        if (cachedInstance != null) {
+            logger.trace("Use cache {}", cachedInstance)
+            @Suppress("UnsafeCallOnNullableType")
+            return cachedInstance!!
+        }
+
+        val instance = (
+            instanceRepository.findByUrl(applicationConfig.url.toURI())
+                ?: throw InternalServerException("Local instance not found.")
+            )
+
+        cachedInstance = Instance.of(instance)
+        @Suppress("UnsafeCallOnNullableType")
+        return cachedInstance!!
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(GetLocalInstanceApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/instance/Instance.kt

@@ -0,0 +1,17 @@
+package dev.usbharu.hideout.core.application.instance
+
+import dev.usbharu.hideout.core.domain.model.instance.Instance
+import java.net.URI
+
+data class Instance(val id: Long, val name: String, val url: URI, val description: String) {
+    companion object {
+        fun of(instance: Instance): dev.usbharu.hideout.core.application.instance.Instance {
+            return Instance(
+                instance.id.instanceId,
+                instance.name.name,
+                instance.url,
+                instance.description.description
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/media/UploadMediaApplicationService.kt

@@ -19,7 +19,7 @@ package dev.usbharu.hideout.core.application.media
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.media.*
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import dev.usbharu.hideout.core.domain.shared.id.IdGenerateService
 import dev.usbharu.hideout.core.external.media.MediaProcessor
 import dev.usbharu.hideout.core.external.mediastore.MediaStore
@@ -39,7 +39,7 @@ class UploadMediaApplicationService(
     transaction,
     logger
 ) {
-    override suspend fun internalExecute(command: UploadMedia, principal: FromApi): Media {
+    override suspend fun internalExecute(command: UploadMedia, principal: LocalUser): Media {
         val process = mediaProcessor.process(command.path, command.name, null)
         val id = idGenerateService.generateId()
         val thumbnailUri = if (process.thumbnailPath != null) {
@@ -58,7 +58,8 @@ class UploadMediaApplicationService(
             type = process.fileType,
             mimeType = process.mimeType,
             blurHash = process.blurHash?.let { MediaBlurHash(it) },
-            description = command.description?.let { MediaDescription(it) }
+            description = command.description?.let { MediaDescription(it) },
+            actorId = principal.actorId
         )
 
         mediaRepository.save(media)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/model/Reactions.kt

@@ -0,0 +1,28 @@
+package dev.usbharu.hideout.core.application.model
+
+import dev.usbharu.hideout.core.domain.model.emoji.CustomEmoji
+import dev.usbharu.hideout.core.domain.model.reaction.Reaction
+import java.net.URI
+
+data class Reactions(
+    val postId: Long,
+    val count: Int,
+    val name: String,
+    val domain: String,
+    val url: URI?,
+    val actorIds: List<Long>,
+) {
+    companion object {
+        fun of(reactionList: List<Reaction>, customEmoji: CustomEmoji?): Reactions {
+            val first = reactionList.first()
+            return Reactions(
+                first.id.value,
+                reactionList.size,
+                customEmoji?.name ?: first.unicodeEmoji.name,
+                customEmoji?.domain?.domain ?: first.unicodeEmoji.domain.domain,
+                customEmoji?.url,
+                reactionList.map { it.actorId.id }
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/model/Timeline.kt

@@ -0,0 +1,23 @@
+package dev.usbharu.hideout.core.application.model
+
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineVisibility
+
+data class Timeline(
+    val id: Long,
+    val userDetailId: Long,
+    val name: String,
+    val visibility: TimelineVisibility,
+    val isSystem: Boolean
+) {
+    companion object {
+        fun of(timeline: dev.usbharu.hideout.core.domain.model.timeline.Timeline): Timeline {
+            return Timeline(
+                timeline.id.value,
+                timeline.userDetailId.id,
+                timeline.name.value,
+                timeline.visibility,
+                timeline.isSystem
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/ActorDetail.kt

@@ -0,0 +1,31 @@
+package dev.usbharu.hideout.core.application.post
+
+import dev.usbharu.hideout.core.domain.model.actor.Actor
+import dev.usbharu.hideout.core.domain.model.media.Media
+import java.net.URI
+
+data class ActorDetail(
+    val actorId: Long,
+    val instanceId: Long,
+    val name: String,
+    val domain: String,
+    val screenName: String,
+    val url: URI,
+    val locked: Boolean,
+    val icon: URI?,
+) {
+    companion object {
+        fun of(actor: Actor, iconMedia: Media?): ActorDetail {
+            return ActorDetail(
+                actorId = actor.id.id,
+                instanceId = actor.instance.instanceId,
+                name = actor.name.name,
+                domain = actor.domain.domain,
+                screenName = actor.screenName.screenName,
+                url = actor.url,
+                locked = actor.locked,
+                icon = iconMedia?.url
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/DeleteLocalPostApplicationService.kt

@@ -16,28 +16,32 @@
 
 package dev.usbharu.hideout.core.application.post
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.exception.PermissionDeniedException
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.post.PostId
 import dev.usbharu.hideout.core.domain.model.post.PostRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
 @Service
 class DeleteLocalPostApplicationService(
     private val postRepository: PostRepository,
-    private val actorRepository: ActorRepository, transaction: Transaction,
+    private val actorRepository: ActorRepository,
+    transaction: Transaction,
 ) : LocalUserAbstractApplicationService<DeleteLocalPost, Unit>(transaction, logger) {
 
-    override suspend fun internalExecute(command: DeleteLocalPost, principal: FromApi) {
-        val findById = postRepository.findById(PostId(command.postId))!!
+    override suspend fun internalExecute(command: DeleteLocalPost, principal: LocalUser) {
+        val findById = postRepository.findById(PostId(command.postId))
+            ?: throw IllegalArgumentException("Post ${command.postId} not found.")
         if (findById.actorId != principal.actorId) {
             throw PermissionDeniedException()
         }
-        val actor = actorRepository.findById(principal.actorId)!!
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
         findById.delete(actor)
         postRepository.save(findById)
     }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/GetPostDetail.kt

@@ -0,0 +1,3 @@
+package dev.usbharu.hideout.core.application.post
+
+data class GetPostDetail(val postId: Long)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/GetPostDetailApplicationService.kt

@@ -0,0 +1,99 @@
+package dev.usbharu.hideout.core.application.post
+
+import dev.usbharu.hideout.core.application.exception.InternalServerException
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.actor.Actor
+import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
+import dev.usbharu.hideout.core.domain.model.media.Media
+import dev.usbharu.hideout.core.domain.model.media.MediaRepository
+import dev.usbharu.hideout.core.domain.model.post.PostId
+import dev.usbharu.hideout.core.domain.model.post.PostRepository
+import dev.usbharu.hideout.core.domain.model.reaction.ReactionRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.domain.service.post.IPostReadAccessControl
+import dev.usbharu.hideout.core.query.reactions.ReactionsQueryService
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class GetPostDetailApplicationService(
+    transaction: Transaction,
+    private val postRepository: PostRepository,
+    private val actorRepository: ActorRepository,
+    private val mediaRepository: MediaRepository,
+    private val iPostReadAccessControl: IPostReadAccessControl,
+    private val reactionsQueryService: ReactionsQueryService,
+    private val reactionRepository: ReactionRepository,
+) : AbstractApplicationService<GetPostDetail, PostDetail>(
+    transaction,
+    logger
+) {
+    override suspend fun internalExecute(command: GetPostDetail, principal: Principal): PostDetail {
+        val post = postRepository.findById(PostId(command.postId))
+            ?: throw IllegalArgumentException("Post ${command.postId} not found.")
+        if (iPostReadAccessControl.isAllow(post, principal).not()) {
+            throw IllegalArgumentException("Post ${command.postId} not found.")
+        }
+        val actor =
+            actorRepository.findById(post.actorId) ?: throw InternalServerException("Actor ${post.actorId} not found.")
+
+        val iconMedia = actor.icon?.let { mediaRepository.findById(it) }
+
+        val mediaList = mediaRepository.findByIds(post.mediaIds)
+
+        val reactions = reactionsQueryService.findAllByPostId(post.id)
+
+        val favourited = reactionRepository.existsByPostIdAndActorIdAndCustomEmojiIdOrUnicodeEmoji(
+            post.id,
+            principal.actorId,
+            null,
+            "❤"
+        )
+
+        return PostDetail.of(
+            post = post,
+            actor = actor,
+            iconMedia = iconMedia,
+            mediaList = mediaList,
+            reply = post.replyId?.let { fetchChild(it, actor, iconMedia, principal) },
+            repost = post.repostId?.let { fetchChild(it, actor, iconMedia, principal) },
+            moveTo = post.moveTo?.let { fetchChild(it, actor, iconMedia, principal) },
+            reactionsList = reactions,
+            favourited
+        )
+    }
+
+    private suspend fun fetchChild(
+        postId: PostId,
+        actor: Actor,
+        iconMedia: Media?,
+        principal: Principal
+    ): PostDetail? {
+        val post = postRepository.findById(postId) ?: return null
+
+        if (iPostReadAccessControl.isAllow(post, principal).not()) {
+            return null
+        }
+
+        val (first, third) = if (actor.id != post.actorId) {
+            (actorRepository.findById(post.actorId) ?: return null) to actor.icon?.let { mediaRepository.findById(it) }
+        } else {
+            actor to iconMedia
+        }
+
+        val mediaList = mediaRepository.findByIds(post.mediaIds)
+        return PostDetail.of(
+            post = post,
+            actor = first,
+            iconMedia = third,
+            mediaList = mediaList,
+            reactionsList = emptyList(),
+            favourited = false
+        )
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(GetPostDetailApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/MediaDetail.kt

@@ -0,0 +1,30 @@
+package dev.usbharu.hideout.core.application.post
+
+import dev.usbharu.hideout.core.domain.model.media.Media
+import java.net.URI
+
+data class MediaDetail(
+    val mediaId: Long,
+    val type: String,
+    val url: URI,
+    val thumbnailUrl: URI?,
+    val sensitive: Boolean,
+    val description: String,
+    val blurhash: String,
+    val actorId: Long
+) {
+    companion object {
+        fun of(media: Media): MediaDetail {
+            return MediaDetail(
+                mediaId = media.id.id,
+                type = media.type.name,
+                url = media.url,
+                thumbnailUrl = media.thumbnailUrl,
+                sensitive = false,
+                description = media.description?.description.orEmpty(),
+                blurhash = media.blurHash?.hash.orEmpty(),
+                actorId = media.actorId.id
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/PostDetail.kt

@@ -0,0 +1,66 @@
+package dev.usbharu.hideout.core.application.post
+
+import dev.usbharu.hideout.core.application.model.Reactions
+import dev.usbharu.hideout.core.domain.model.actor.Actor
+import dev.usbharu.hideout.core.domain.model.media.Media
+import dev.usbharu.hideout.core.domain.model.post.Post
+import dev.usbharu.hideout.core.domain.model.post.Visibility
+import java.net.URI
+import java.time.Instant
+
+data class PostDetail(
+    val id: Long,
+    val actor: ActorDetail,
+    val overview: String?,
+    val text: String,
+    val content: String,
+    val createdAt: Instant,
+    val visibility: Visibility,
+    val pureRepost: Boolean,
+    val url: URI,
+    val apId: URI,
+    val repost: PostDetail?,
+    val reply: PostDetail?,
+    val sensitive: Boolean,
+    val deleted: Boolean,
+    val mediaDetailList: List<MediaDetail>,
+    val moveTo: PostDetail?,
+    val reactionsList: List<Reactions>,
+    val favourited: Boolean
+) {
+    companion object {
+        @Suppress("LongParameterList")
+        fun of(
+            post: Post,
+            actor: Actor,
+            iconMedia: Media?,
+            mediaList: List<Media>,
+            reply: PostDetail? = null,
+            repost: PostDetail? = null,
+            moveTo: PostDetail? = null,
+            reactionsList: List<Reactions>,
+            favourited: Boolean
+        ): PostDetail {
+            return PostDetail(
+                id = post.id.id,
+                actor = ActorDetail.of(actor, iconMedia),
+                overview = post.overview?.overview,
+                text = post.text,
+                content = post.content.content,
+                createdAt = post.createdAt,
+                visibility = post.visibility,
+                pureRepost = post.isPureRepost,
+                url = post.url,
+                apId = post.apId,
+                repost = repost,
+                reply = reply,
+                sensitive = post.sensitive,
+                deleted = false,
+                mediaDetailList = mediaList.map { MediaDetail.of(it) },
+                moveTo = moveTo,
+                reactionsList = reactionsList,
+                favourited = favourited
+            )
+        }
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/RegisterLocalPostApplicationService.kt

@@ -24,7 +24,7 @@ import dev.usbharu.hideout.core.domain.model.media.MediaId
 import dev.usbharu.hideout.core.domain.model.post.PostId
 import dev.usbharu.hideout.core.domain.model.post.PostOverview
 import dev.usbharu.hideout.core.domain.model.post.PostRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import dev.usbharu.hideout.core.infrastructure.factory.PostFactoryImpl
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -38,7 +38,7 @@ class RegisterLocalPostApplicationService(
     transaction: Transaction,
 ) : LocalUserAbstractApplicationService<RegisterLocalPost, Long>(transaction, Companion.logger) {
 
-    override suspend fun internalExecute(command: RegisterLocalPost, principal: FromApi): Long {
+    override suspend fun internalExecute(command: RegisterLocalPost, principal: LocalUser): Long {
         val actorId = principal.actorId
 
         val actor = actorRepository.findById(actorId) ?: throw InternalServerException("Actor $actorId not found.")

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/post/UpdateLocalNoteApplicationService.kt

@@ -25,7 +25,7 @@ import dev.usbharu.hideout.core.domain.model.media.MediaId
 import dev.usbharu.hideout.core.domain.model.post.PostId
 import dev.usbharu.hideout.core.domain.model.post.PostOverview
 import dev.usbharu.hideout.core.domain.model.post.PostRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
 import dev.usbharu.hideout.core.infrastructure.factory.PostContentFactoryImpl
 import org.slf4j.LoggerFactory
@@ -40,7 +40,7 @@ class UpdateLocalNoteApplicationService(
     private val actorRepository: ActorRepository,
 ) : LocalUserAbstractApplicationService<UpdateLocalNote, Unit>(transaction, logger) {
 
-    override suspend fun internalExecute(command: UpdateLocalNote, principal: FromApi) {
+    override suspend fun internalExecute(command: UpdateLocalNote, principal: LocalUser) {
         val post = postRepository.findById(PostId(command.postId))
             ?: throw IllegalArgumentException("Post ${command.postId} not found.")
         if (post.actorId != principal.actorId) {

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/reaction/CreateReaction.kt

@@ -0,0 +1,3 @@
+package dev.usbharu.hideout.core.application.reaction
+
+data class CreateReaction(val postId: Long, val customEmojiId: Long?, val unicodeEmoji: String)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/reaction/RemoveReaction.kt

@@ -0,0 +1,7 @@
+package dev.usbharu.hideout.core.application.reaction
+
+data class RemoveReaction(
+    val postId: Long,
+    val customEmojiId: Long?,
+    val unicodeEmoji: String
+)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/reaction/UserCreateReactionApplicationService.kt

@@ -0,0 +1,65 @@
+package dev.usbharu.hideout.core.application.reaction
+
+import dev.usbharu.hideout.core.application.exception.PermissionDeniedException
+import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.emoji.CustomEmojiRepository
+import dev.usbharu.hideout.core.domain.model.emoji.UnicodeEmoji
+import dev.usbharu.hideout.core.domain.model.post.PostId
+import dev.usbharu.hideout.core.domain.model.post.PostRepository
+import dev.usbharu.hideout.core.domain.model.reaction.Reaction
+import dev.usbharu.hideout.core.domain.model.reaction.ReactionId
+import dev.usbharu.hideout.core.domain.model.reaction.ReactionRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
+import dev.usbharu.hideout.core.domain.service.emoji.UnicodeEmojiService
+import dev.usbharu.hideout.core.domain.service.post.IPostReadAccessControl
+import dev.usbharu.hideout.core.domain.shared.id.IdGenerateService
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+import java.time.Instant
+
+@Service
+class UserCreateReactionApplicationService(
+    transaction: Transaction,
+    private val idGenerateService: IdGenerateService,
+    private val reactionRepository: ReactionRepository,
+    private val postReadAccessControl: IPostReadAccessControl,
+    private val postRepository: PostRepository,
+    private val customEmojiRepository: CustomEmojiRepository,
+    private val unicodeEmojiService: UnicodeEmojiService
+) :
+    LocalUserAbstractApplicationService<CreateReaction, Unit>(
+        transaction,
+        logger
+    ) {
+    override suspend fun internalExecute(command: CreateReaction, principal: LocalUser) {
+        val postId = PostId(command.postId)
+        val post = postRepository.findById(postId) ?: throw IllegalArgumentException("Post $postId not found.")
+        if (postReadAccessControl.isAllow(post, principal).not()) {
+            throw PermissionDeniedException()
+        }
+
+        val customEmoji = command.customEmojiId?.let { customEmojiRepository.findById(it) }
+
+        val unicodeEmoji = if (unicodeEmojiService.isUnicodeEmoji(command.unicodeEmoji)) {
+            command.unicodeEmoji
+        } else {
+            "❤"
+        }
+
+        val reaction = Reaction.create(
+            id = ReactionId(idGenerateService.generateId()),
+            postId = postId,
+            actorId = principal.actorId,
+            customEmojiId = customEmoji?.id,
+            unicodeEmoji = UnicodeEmoji(unicodeEmoji),
+            createdAt = Instant.now()
+        )
+
+        reactionRepository.save(reaction)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UserCreateReactionApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/reaction/UserRemoveReactionApplicationService.kt

@@ -0,0 +1,51 @@
+package dev.usbharu.hideout.core.application.reaction
+
+import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.emoji.CustomEmojiRepository
+import dev.usbharu.hideout.core.domain.model.post.PostId
+import dev.usbharu.hideout.core.domain.model.reaction.ReactionRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
+import dev.usbharu.hideout.core.domain.service.emoji.UnicodeEmojiService
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class UserRemoveReactionApplicationService(
+    transaction: Transaction,
+    private val customEmojiRepository: CustomEmojiRepository,
+    private val reactionRepository: ReactionRepository,
+    private val unicodeEmojiService: UnicodeEmojiService
+) :
+    LocalUserAbstractApplicationService<RemoveReaction, Unit>(
+        transaction,
+        logger
+    ) {
+    override suspend fun internalExecute(command: RemoveReaction, principal: LocalUser) {
+        val postId = PostId(command.postId)
+
+        val customEmoji = command.customEmojiId?.let { customEmojiRepository.findById(it) }
+
+        val unicodeEmoji = if (unicodeEmojiService.isUnicodeEmoji(command.unicodeEmoji)) {
+            command.unicodeEmoji
+        } else {
+            "❤"
+        }
+        val reaction =
+            reactionRepository.findByPostIdAndActorIdAndCustomEmojiIdOrUnicodeEmoji(
+                postId,
+                principal.actorId,
+                customEmoji?.id,
+                unicodeEmoji
+            )
+                ?: throw IllegalArgumentException("Reaction $postId ${principal.actorId} ${customEmoji?.id} $unicodeEmoji not found.")
+
+        reaction.delete()
+
+        reactionRepository.delete(reaction)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UserRemoveReactionApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/acceptfollowrequest/UserAcceptFollowRequestApplicationService.kt

@@ -23,7 +23,7 @@ import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -34,8 +34,7 @@ class UserAcceptFollowRequestApplicationService(
     private val actorRepository: ActorRepository,
 ) :
     LocalUserAbstractApplicationService<AcceptFollowRequest, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: AcceptFollowRequest, principal: FromApi) {
-
+    override suspend fun internalExecute(command: AcceptFollowRequest, principal: LocalUser) {
         val actor = actorRepository.findById(principal.actorId)
             ?: throw InternalServerException("Actor ${principal.actorId} not found")
 

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/block/UserBlockApplicationService.kt

@@ -22,8 +22,7 @@ import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.Relationship
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import dev.usbharu.hideout.core.domain.service.relationship.RelationshipDomainService
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
@@ -33,14 +32,12 @@ class UserBlockApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
     private val relationshipDomainService: RelationshipDomainService,
 ) :
     LocalUserAbstractApplicationService<Block, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: Block, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: Block, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw IllegalStateException("Actor ${principal.actorId} not found")
 
         val targetId = ActorId(command.targetActorId)
         val relationship = relationshipRepository.findByActorIdAndTargetId(actor.id, targetId) ?: Relationship.default(

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/followrequest/UserFollowRequestApplicationService.kt

@@ -16,14 +16,14 @@
 
 package dev.usbharu.hideout.core.application.relationship.followrequest
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.Relationship
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -32,16 +32,14 @@ class UserFollowRequestApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
 ) : LocalUserAbstractApplicationService<FollowRequest, Unit>(
     transaction,
     logger
 ) {
 
-    override suspend fun internalExecute(command: FollowRequest, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: FollowRequest, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
 
         val targetId = ActorId(command.targetActorId)
         val relationship = relationshipRepository.findByActorIdAndTargetId(actor.id, targetId) ?: Relationship.default(

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/get/GetRelationshipApplicationService.kt

@@ -16,6 +16,7 @@
 
 package dev.usbharu.hideout.core.application.relationship.get
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorId
@@ -23,8 +24,7 @@ import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.actorinstancerelationship.ActorInstanceRelationship
 import dev.usbharu.hideout.core.domain.model.actorinstancerelationship.ActorInstanceRelationshipRepository
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -32,7 +32,6 @@ import org.springframework.stereotype.Service
 class GetRelationshipApplicationService(
     private val relationshipRepository: RelationshipRepository,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
     private val actorInstanceRelationshipRepository: ActorInstanceRelationshipRepository,
     transaction: Transaction,
 ) :
@@ -40,11 +39,12 @@ class GetRelationshipApplicationService(
         transaction,
         logger
     ) {
-    override suspend fun internalExecute(command: GetRelationship, principal: FromApi): Relationship {
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: GetRelationship, principal: LocalUser): Relationship {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
         val targetId = ActorId(command.targetActorId)
-        val target = actorRepository.findById(targetId)!!
+        val target = actorRepository.findById(targetId)
+            ?: throw IllegalArgumentException("Actor ${command.targetActorId} not found.")
         val relationship = (
             relationshipRepository.findByActorIdAndTargetId(actor.id, targetId)
                 ?: dev.usbharu.hideout.core.domain.model.relationship.Relationship.default(actor.id, targetId)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/mute/UserMuteApplicationService.kt

@@ -16,6 +16,7 @@
 
 package dev.usbharu.hideout.core.application.relationship.mute
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.relationship.block.UserBlockApplicationService
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
@@ -23,8 +24,7 @@ import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.Relationship
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -33,13 +33,11 @@ class UserMuteApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
 ) :
     LocalUserAbstractApplicationService<Mute, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: Mute, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: Mute, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
 
         val targetId = ActorId(command.targetActorId)
         val relationship = relationshipRepository.findByActorIdAndTargetId(actor.id, targetId) ?: Relationship.default(

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/rejectfollowrequest/UserRejectFollowRequestApplicationService.kt

@@ -16,14 +16,14 @@
 
 package dev.usbharu.hideout.core.application.relationship.rejectfollowrequest
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.relationship.block.UserBlockApplicationService
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
 import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -32,18 +32,16 @@ class UserRejectFollowRequestApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
 ) :
     LocalUserAbstractApplicationService<RejectFollowRequest, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: RejectFollowRequest, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: RejectFollowRequest, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
 
         val targetId = ActorId(command.sourceActorId)
 
         val relationship = relationshipRepository.findByActorIdAndTargetId(targetId, actor.id)
-            ?: throw Exception("Follow request not found")
+            ?: throw IllegalArgumentException("Follow request not found")
 
         relationship.rejectFollowRequest()
 

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/removefromfollowers/UserRemoveFromFollowersApplicationService.kt

@@ -16,6 +16,7 @@
 
 package dev.usbharu.hideout.core.application.relationship.removefromfollowers
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.relationship.block.UserBlockApplicationService
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
@@ -23,8 +24,7 @@ import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.Relationship
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -33,13 +33,11 @@ class UserRemoveFromFollowersApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
 ) :
     LocalUserAbstractApplicationService<RemoveFromFollowers, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: RemoveFromFollowers, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: RemoveFromFollowers, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
 
         val targetId = ActorId(command.targetActorId)
         val relationship = relationshipRepository.findByActorIdAndTargetId(targetId, actor.id) ?: Relationship.default(

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/unblock/UserUnblockApplicationService.kt

@@ -16,6 +16,7 @@
 
 package dev.usbharu.hideout.core.application.relationship.unblock
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.relationship.block.UserBlockApplicationService
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
@@ -23,8 +24,7 @@ import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.Relationship
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -33,13 +33,11 @@ class UserUnblockApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
 ) :
     LocalUserAbstractApplicationService<Unblock, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: Unblock, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: Unblock, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
 
         val targetId = ActorId(command.targetActorId)
         val relationship = relationshipRepository.findByActorIdAndTargetId(actor.id, targetId) ?: Relationship.default(

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/unfollow/UserUnfollowApplicationService.kt

@@ -16,6 +16,7 @@
 
 package dev.usbharu.hideout.core.application.relationship.unfollow
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.relationship.block.UserBlockApplicationService
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
@@ -23,8 +24,7 @@ import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.Relationship
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -33,13 +33,11 @@ class UserUnfollowApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
 ) :
     LocalUserAbstractApplicationService<Unfollow, Unit>(transaction, logger) {
-    override suspend fun internalExecute(command: Unfollow, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: Unfollow, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
 
         val targetId = ActorId(command.targetActorId)
         val relationship = relationshipRepository.findByActorIdAndTargetId(actor.id, targetId) ?: Relationship.default(

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/relationship/unmute/UserUnmuteApplicationService.kt

@@ -16,6 +16,7 @@
 
 package dev.usbharu.hideout.core.application.relationship.unmute
 
+import dev.usbharu.hideout.core.application.exception.InternalServerException
 import dev.usbharu.hideout.core.application.relationship.block.UserBlockApplicationService
 import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
@@ -23,8 +24,7 @@ import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.actor.ActorRepository
 import dev.usbharu.hideout.core.domain.model.relationship.Relationship
 import dev.usbharu.hideout.core.domain.model.relationship.RelationshipRepository
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
-import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
@@ -33,17 +33,11 @@ class UserUnmuteApplicationService(
     private val relationshipRepository: RelationshipRepository,
     transaction: Transaction,
     private val actorRepository: ActorRepository,
-    private val userDetailRepository: UserDetailRepository,
 ) :
     LocalUserAbstractApplicationService<Unmute, Unit>(transaction, logger) {
-    companion object {
-        private val logger = LoggerFactory.getLogger(UserBlockApplicationService::class.java)
-    }
-
-    override suspend fun internalExecute(command: Unmute, principal: FromApi) {
-
-        val userDetail = userDetailRepository.findById(principal.userDetailId)!!
-        val actor = actorRepository.findById(userDetail.actorId)!!
+    override suspend fun internalExecute(command: Unmute, principal: LocalUser) {
+        val actor = actorRepository.findById(principal.actorId)
+            ?: throw InternalServerException("Actor ${principal.actorId} not found.")
 
         val targetId = ActorId(command.targetActorId)
         val relationship = relationshipRepository.findByActorIdAndTargetId(actor.id, targetId) ?: Relationship.default(
@@ -55,4 +49,8 @@ class UserUnmuteApplicationService(
 
         relationshipRepository.save(relationship)
     }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UserBlockApplicationService::class.java)
+    }
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/shared/AbstractApplicationService.kt

@@ -30,12 +30,13 @@ abstract class AbstractApplicationService<T : Any, R>(
             val response = transaction.transaction<R> {
                 internalExecute(command, principal)
             }
-            logger.info("SUCCESS ${command::class.simpleName}")
+
+            logger.info("SUCCESS $command $response")
             response
         } catch (e: CancellationException) {
             logger.debug("Coroutine canceled", e)
             throw e
-        } catch (e: Exception) {
+        } catch (@Suppress("TooGenericExceptionCaught") e: Exception) {
             logger.warn("Command execution error", e)
             throw e
         }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/shared/LocalUserAbstractApplicationService.kt

@@ -1,15 +1,18 @@
 package dev.usbharu.hideout.core.application.shared
 
-import dev.usbharu.hideout.core.domain.model.support.principal.FromApi
+import dev.usbharu.hideout.core.application.exception.PermissionDeniedException
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
 import dev.usbharu.hideout.core.domain.model.support.principal.Principal
 import org.slf4j.Logger
 
 abstract class LocalUserAbstractApplicationService<T : Any, R>(transaction: Transaction, logger: Logger) :
     AbstractApplicationService<T, R>(transaction, logger) {
     override suspend fun internalExecute(command: T, principal: Principal): R {
-        require(principal is FromApi)
+        if (principal !is LocalUser) {
+            throw PermissionDeniedException()
+        }
         return internalExecute(command, principal)
     }
 
-    protected abstract suspend fun internalExecute(command: T, principal: FromApi): R
-}
+    protected abstract suspend fun internalExecute(command: T, principal: LocalUser): R
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/AddPost.kt

@@ -0,0 +1,5 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.domain.model.post.PostId
+
+data class AddPost(val postId: PostId)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/AddTimelineRelationship.kt

@@ -1,7 +1,11 @@
 package dev.usbharu.hideout.core.application.timeline
 
-import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationship
+import dev.usbharu.hideout.core.domain.model.actor.ActorId
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineId
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.Visible
 
 data class AddTimelineRelationship(
-    val timelineRelationship: TimelineRelationship
+    val timelineId: TimelineId,
+    val actorId: ActorId,
+    val visible: Visible
 )

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/GetTimelines.kt

@@ -0,0 +1,3 @@
+package dev.usbharu.hideout.core.application.timeline
+
+data class GetTimelines(val userDetailId: Long)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/GetUserTimeline.kt

@@ -0,0 +1,5 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.domain.model.support.page.Page
+
+data class GetUserTimeline(val id: Long, val page: Page)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/GetUserTimelineApplicationService.kt

@@ -0,0 +1,53 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.application.post.PostDetail
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.actor.ActorId
+import dev.usbharu.hideout.core.domain.model.post.PostId
+import dev.usbharu.hideout.core.domain.model.post.PostRepository
+import dev.usbharu.hideout.core.domain.model.post.Visibility
+import dev.usbharu.hideout.core.domain.model.support.page.PaginationList
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.query.usertimeline.UserTimelineQueryService
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class GetUserTimelineApplicationService(
+    private val userTimelineQueryService: UserTimelineQueryService,
+    private val postRepository: PostRepository,
+    transaction: Transaction
+) :
+    AbstractApplicationService<GetUserTimeline, PaginationList<PostDetail, PostId>>(transaction, logger) {
+    override suspend fun internalExecute(
+        command: GetUserTimeline,
+        principal: Principal
+    ): PaginationList<PostDetail, PostId> {
+        val postList = postRepository.findByActorIdAndVisibilityInList(
+            ActorId(command.id),
+            listOf(Visibility.PUBLIC, Visibility.UNLISTED, Visibility.FOLLOWERS),
+            command.page
+        )
+
+        val postIdList =
+            postList.mapNotNull { it.repostId } + postList.mapNotNull { it.replyId } + postList.map { it.id }
+
+        val postDetailMap = userTimelineQueryService.findByIdAll(postIdList, principal).associateBy { it.id }
+
+        return PaginationList(
+            postList.mapNotNull {
+                postDetailMap[it.id.id]?.copy(
+                    repost = postDetailMap[it.repostId?.id],
+                    reply = postDetailMap[it.replyId?.id]
+                )
+            },
+            postList.next,
+            postList.prev
+        )
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(GetUserTimelineApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/ReadTimeline.kt

@@ -0,0 +1,11 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.domain.model.support.page.Page
+
+data class ReadTimeline(
+    val timelineId: Long,
+    val mediaOnly: Boolean,
+    val localOnly: Boolean,
+    val remoteOnly: Boolean,
+    val page: Page
+)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/ReadTimelineApplicationService.kt

@@ -0,0 +1,90 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.application.post.PostDetail
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.post.PostId
+import dev.usbharu.hideout.core.domain.model.support.page.PaginationList
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineId
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineRepository
+import dev.usbharu.hideout.core.external.timeline.ReadTimelineOption
+import dev.usbharu.hideout.core.external.timeline.TimelineStore
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class ReadTimelineApplicationService(
+    private val timelineStore: TimelineStore,
+    private val timelineRepository: TimelineRepository,
+    transaction: Transaction
+) :
+    AbstractApplicationService<ReadTimeline, PaginationList<PostDetail, PostId>>(transaction, logger) {
+    override suspend fun internalExecute(
+        command: ReadTimeline,
+        principal: Principal
+    ): PaginationList<PostDetail, PostId> {
+        val findById = timelineRepository.findById(TimelineId(command.timelineId))
+            ?: throw IllegalArgumentException("Timeline ${command.timelineId} not found.")
+
+        val readTimelineOption = ReadTimelineOption(
+            command.mediaOnly,
+            command.localOnly,
+            command.remoteOnly
+        )
+
+        val timeline = timelineStore.readTimeline(
+            findById,
+            readTimelineOption,
+            command.page,
+            principal,
+        )
+
+        val postDetailList = timeline.map {
+            val reply = if (it.replyPost != null) {
+                @Suppress("UnsafeCallOnNullableType")
+                PostDetail.of(
+                    it.replyPost,
+                    it.replyPostActor!!,
+                    it.replyPostActorIconMedia,
+                    it.replyPostMedias.orEmpty(),
+                    reactionsList = emptyList(),
+                    favourited = false,
+                )
+            } else {
+                null
+            }
+
+            val repost = if (it.repostPost != null) {
+                @Suppress("UnsafeCallOnNullableType")
+                PostDetail.of(
+                    post = it.repostPost,
+                    actor = it.repostPostActor!!,
+                    iconMedia = it.repostPostActorIconMedia,
+                    mediaList = it.repostPostMedias.orEmpty(),
+                    reactionsList = emptyList(),
+                    favourited = false
+                )
+            } else {
+                null
+            }
+
+            PostDetail.of(
+                post = it.post,
+                actor = it.postActor,
+                iconMedia = it.postActorIconMedia,
+                mediaList = it.postMedias,
+                reply = reply,
+                repost = repost,
+                reactionsList = emptyList(),
+                favourited = it.favourited
+            )
+        }
+
+        return PaginationList(postDetailList, timeline.next, timeline.prev)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(ReadTimelineApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/RegisterTimeline.kt

@@ -0,0 +1,8 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineVisibility
+
+data class RegisterTimeline(
+    val timelineName: String,
+    val visibility: TimelineVisibility
+)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/RemoveTimelineRelationship.kt

@@ -0,0 +1,5 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipId
+
+data class RemoveTimelineRelationship(val timelineRelationshipId: TimelineRelationshipId)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/SetTimelineToTimelineStoreApplicationService.kt

@@ -0,0 +1,30 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineRepository
+import dev.usbharu.hideout.core.external.timeline.TimelineStore
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Component
+
+@Component
+class SetTimelineToTimelineStoreApplicationService(
+    transaction: Transaction,
+    private val timelineStore: TimelineStore,
+    private val timelineRepository: TimelineRepository
+) :
+    AbstractApplicationService<SetTimleineStore, Unit>(
+        transaction,
+        logger
+    ) {
+    override suspend fun internalExecute(command: SetTimleineStore, principal: Principal) {
+        val findById = timelineRepository.findById(command.timelineId)
+            ?: throw IllegalArgumentException("Timeline ${command.timelineId} not found")
+        timelineStore.addTimeline(findById, emptyList())
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(SetTimelineToTimelineStoreApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/SetTimleineStore.kt

@@ -0,0 +1,5 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineId
+
+data class SetTimleineStore(val timelineId: TimelineId)

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/TimelineAddPostApplicationService.kt

@@ -0,0 +1,29 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.post.PostRepository
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.external.timeline.TimelineStore
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Component
+
+@Component
+class TimelineAddPostApplicationService(
+    private val timelineStore: TimelineStore,
+    private val postRepository: PostRepository,
+    transaction: Transaction
+) : AbstractApplicationService<AddPost, Unit>(
+    transaction,
+    logger
+) {
+    override suspend fun internalExecute(command: AddPost, principal: Principal) {
+        val findById = postRepository.findById(command.postId)
+            ?: throw IllegalArgumentException("Post ${command.postId} not found.")
+        timelineStore.addPost(findById)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(TimelineAddPostApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/UserAddTimelineRelationshipApplicationService.kt

@@ -1,26 +1,47 @@
 package dev.usbharu.hideout.core.application.timeline
 
-import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.exception.PermissionDeniedException
+import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
 import dev.usbharu.hideout.core.application.shared.Transaction
-import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineRepository
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationship
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipId
 import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipRepository
+import dev.usbharu.hideout.core.domain.shared.id.IdGenerateService
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
 @Service
 class UserAddTimelineRelationshipApplicationService(
     private val timelineRelationshipRepository: TimelineRelationshipRepository,
+    private val timelineRepository: TimelineRepository,
+    private val idGenerateService: IdGenerateService,
     transaction: Transaction
 ) :
-    AbstractApplicationService<AddTimelineRelationship, Unit>(
-        transaction, logger
+    LocalUserAbstractApplicationService<AddTimelineRelationship, Unit>(
+        transaction,
+        logger
     ) {
-    override suspend fun internalExecute(command: AddTimelineRelationship, principal: Principal) {
-        timelineRelationshipRepository.save(command.timelineRelationship)
+    override suspend fun internalExecute(command: AddTimelineRelationship, principal: LocalUser) {
+        val timeline = timelineRepository.findById(command.timelineId)
+            ?: throw IllegalArgumentException("Timeline ${command.timelineId} not found.")
 
+        if (timeline.userDetailId != principal.userDetailId) {
+            throw PermissionDeniedException()
+        }
+
+        timelineRelationshipRepository.save(
+            TimelineRelationship(
+                TimelineRelationshipId(idGenerateService.generateId()),
+                command.timelineId,
+                command.actorId,
+                command.visible
+            )
+        )
     }
 
     companion object {
         private val logger = LoggerFactory.getLogger(UserAddTimelineRelationshipApplicationService::class.java)
     }
-}
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/UserGetTimelinesApplicationService.kt

@@ -0,0 +1,37 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.application.model.Timeline
+import dev.usbharu.hideout.core.application.shared.AbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.support.principal.Principal
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineRepository
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineVisibility
+import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailId
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class UserGetTimelinesApplicationService(transaction: Transaction, private val timelineRepository: TimelineRepository) :
+    AbstractApplicationService<GetTimelines, List<Timeline>>(
+        transaction,
+        logger
+    ) {
+    override suspend fun internalExecute(command: GetTimelines, principal: Principal): List<Timeline> {
+        val userDetailId = UserDetailId(command.userDetailId)
+
+        val timelineVisibility = if (userDetailId == principal.userDetailId) {
+            listOf(TimelineVisibility.PUBLIC, TimelineVisibility.UNLISTED, TimelineVisibility.PRIVATE)
+        } else {
+            listOf(TimelineVisibility.PUBLIC)
+        }
+
+        val timelineList =
+            timelineRepository.findAllByUserDetailIdAndVisibilityIn(userDetailId, timelineVisibility)
+
+        return timelineList.map { Timeline.of(it) }
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UserGetTimelinesApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/UserRegisterTimelineApplicationService.kt

@@ -0,0 +1,37 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
+import dev.usbharu.hideout.core.domain.model.timeline.Timeline
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineId
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineName
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineRepository
+import dev.usbharu.hideout.core.domain.shared.id.IdGenerateService
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Component
+
+@Component
+class UserRegisterTimelineApplicationService(
+    private val idGenerateService: IdGenerateService,
+    private val timelineRepository: TimelineRepository,
+    transaction: Transaction
+) :
+    LocalUserAbstractApplicationService<RegisterTimeline, TimelineId>(transaction, logger) {
+    override suspend fun internalExecute(command: RegisterTimeline, principal: LocalUser): TimelineId {
+        val timeline = Timeline.create(
+            id = TimelineId(idGenerateService.generateId()),
+            userDetailId = principal.userDetailId,
+            name = TimelineName(command.timelineName),
+            visibility = command.visibility,
+            isSystem = false
+        )
+
+        timelineRepository.save(timeline)
+        return timeline.id
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UserRegisterTimelineApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/application/timeline/UserRemoveTimelineRelationshipApplicationService.kt

@@ -0,0 +1,44 @@
+package dev.usbharu.hideout.core.application.timeline
+
+import dev.usbharu.hideout.core.application.exception.PermissionDeniedException
+import dev.usbharu.hideout.core.application.shared.LocalUserAbstractApplicationService
+import dev.usbharu.hideout.core.application.shared.Transaction
+import dev.usbharu.hideout.core.domain.model.support.principal.LocalUser
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineRepository
+import dev.usbharu.hideout.core.domain.model.timelinerelationship.TimelineRelationshipRepository
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class UserRemoveTimelineRelationshipApplicationService(
+    transaction: Transaction,
+    private val timelineRelationshipRepository: TimelineRelationshipRepository,
+    private val timelineRepository: TimelineRepository
+) :
+    LocalUserAbstractApplicationService<RemoveTimelineRelationship, Unit>(
+        transaction,
+        logger
+    ) {
+
+    override suspend fun internalExecute(command: RemoveTimelineRelationship, principal: LocalUser) {
+        val timelineRelationship = (
+            timelineRelationshipRepository.findById(command.timelineRelationshipId)
+                ?: throw IllegalArgumentException("TimelineRelationship ${command.timelineRelationshipId} not found.")
+            )
+
+        val timeline = (
+            timelineRepository.findById(timelineRelationship.timelineId)
+                ?: throw IllegalArgumentException("Timeline ${timelineRelationship.timelineId} not found.")
+            )
+
+        if (timeline.userDetailId != principal.userDetailId) {
+            throw PermissionDeniedException()
+        }
+
+        timelineRelationshipRepository.delete(timelineRelationship)
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(UserRemoveTimelineRelationshipApplicationService::class.java)
+    }
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/config/MessageSourceConfig.kt

@@ -0,0 +1,26 @@
+package dev.usbharu.hideout.core.config
+
+import org.springframework.boot.autoconfigure.context.MessageSourceProperties
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.context.MessageSource
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.context.annotation.Profile
+import org.springframework.context.support.ReloadableResourceBundleMessageSource
+
+@Configuration
+@Profile("dev")
+class MessageSourceConfig {
+    @Bean
+    fun messageSource(messageSourceProperties: MessageSourceProperties): MessageSource {
+        val reloadableResourceBundleMessageSource = ReloadableResourceBundleMessageSource()
+        reloadableResourceBundleMessageSource.setBasename("classpath:" + messageSourceProperties.basename)
+        reloadableResourceBundleMessageSource.setCacheSeconds(0)
+        return reloadableResourceBundleMessageSource
+    }
+
+    @Bean
+    @Profile("dev")
+    @ConfigurationProperties(prefix = "spring.messages")
+    fun messageSourceProperties(): MessageSourceProperties = MessageSourceProperties()
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/config/SecurityConfig.kt

@@ -23,6 +23,7 @@ import com.nimbusds.jose.jwk.source.JWKSource
 import com.nimbusds.jose.proc.SecurityContext
 import dev.usbharu.hideout.core.infrastructure.springframework.oauth2.HideoutUserDetails
 import dev.usbharu.hideout.util.RsaUtil
+import org.slf4j.LoggerFactory
 import org.springframework.boot.context.properties.ConfigurationProperties
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
@@ -50,9 +51,13 @@ import org.springframework.security.oauth2.server.authorization.token.JwtEncodin
 import org.springframework.security.oauth2.server.authorization.token.OAuth2TokenCustomizer
 import org.springframework.security.web.SecurityFilterChain
 import org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint
+import java.security.KeyPairGenerator
+import java.security.interfaces.RSAPrivateKey
+import java.security.interfaces.RSAPublicKey
+import java.util.*
 
 @Configuration
-@EnableWebSecurity(debug = true)
+@EnableWebSecurity(debug = false)
 class SecurityConfig {
     @Bean
     fun passwordEncoder(): PasswordEncoder = BCryptPasswordEncoder()
@@ -63,7 +68,7 @@ class SecurityConfig {
         OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http)
         http {
             exceptionHandling {
-                authenticationEntryPoint = LoginUrlAuthenticationEntryPoint("/login")
+                authenticationEntryPoint = LoginUrlAuthenticationEntryPoint("/auth/sign_in")
             }
         }
         return http.build()
@@ -75,16 +80,29 @@ class SecurityConfig {
         http {
             authorizeHttpRequests {
                 authorize("/error", permitAll)
-                authorize("/login", permitAll)
+                authorize("/auth/sign_in", permitAll)
                 authorize(GET, "/.well-known/**", permitAll)
                 authorize(GET, "/nodeinfo/2.0", permitAll)
 
                 authorize(GET, "/auth/sign_up", hasRole("ANONYMOUS"))
                 authorize(POST, "/auth/sign_up", permitAll)
+                authorize(GET, "/users/{username}/posts/{postId}", permitAll)
+                authorize(GET, "/users/{userid}", permitAll)
+                authorize(GET, "/files/*", permitAll)
+                authorize(POST, "/publish", authenticated)
+                authorize(GET, "/publish", authenticated)
+                authorize(GET, "/", permitAll)
 
                 authorize(anyRequest, authenticated)
             }
             formLogin {
+                loginPage = "/auth/sign_in"
+                loginProcessingUrl = "/login"
+                defaultSuccessUrl("/home", false)
+            }
+            logout {
+                logoutUrl = "/auth/sign_out"
+                logoutSuccessUrl = "/auth/sign_in"
             }
         }
         return http.build()
@@ -122,17 +140,55 @@ class SecurityConfig {
     }
 
     @Bean
-    fun loadJwkSource(jwkConfig: JwkConfig): JWKSource<SecurityContext> {
-        val rsaKey = RSAKey.Builder(RsaUtil.decodeRsaPublicKey(jwkConfig.publicKey))
-            .privateKey(RsaUtil.decodeRsaPrivateKey(jwkConfig.privateKey)).keyID(jwkConfig.keyId).build()
+    @Suppress("UnsafeCallOnNullableType")
+    fun loadJwkSource(jwkConfig: JwkConfig, applicationConfig: ApplicationConfig): JWKSource<SecurityContext> {
+        if (jwkConfig.keyId == null) {
+            logger.error("hideout.security.jwt.keyId is null.")
+        }
+        if (jwkConfig.publicKey == null) {
+            logger.error("hideout.security.jwt.publicKey is null.")
+        }
+        if (jwkConfig.privateKey == null) {
+            logger.error("hideout.security.jwt.privateKey is null.")
+        }
+        if (jwkConfig.keyId == null || jwkConfig.publicKey == null || jwkConfig.privateKey == null) {
+            val keyPairGenerator = KeyPairGenerator.getInstance("RSA")
+            keyPairGenerator.initialize(applicationConfig.keySize)
+            val generateKeyPair = keyPairGenerator.generateKeyPair()
+
+            jwkConfig.keyId = UUID.randomUUID().toString()
+            jwkConfig.publicKey = RsaUtil.encodeRsaPublicKey(generateKeyPair.public as RSAPublicKey)
+            jwkConfig.privateKey = RsaUtil.encodeRsaPrivateKey(generateKeyPair.private as RSAPrivateKey)
+            logger.error(
+                """
+                |==============
+                |==============
+                |
+                |**Write the following settings in application.yml**
+                |
+                |hideout:
+                |   security:
+                |       jwt:
+                |           keyId: ${jwkConfig.keyId}
+                |           publicKey: ${jwkConfig.publicKey}
+                |           privateKey: ${jwkConfig.privateKey}
+                |
+                |==============
+                |==============
+                """.trimMargin()
+            )
+        }
+
+        val rsaKey = RSAKey.Builder(RsaUtil.decodeRsaPublicKey(jwkConfig.publicKey!!))
+            .privateKey(RsaUtil.decodeRsaPrivateKey(jwkConfig.privateKey!!)).keyID(jwkConfig.keyId).build()
         return ImmutableJWKSet(JWKSet(rsaKey))
     }
 
     @ConfigurationProperties("hideout.security.jwt")
     data class JwkConfig(
-        val keyId: String,
-        val publicKey: String,
-        val privateKey: String,
+        var keyId: String?,
+        var publicKey: String?,
+        var privateKey: String?,
     )
 
     @Bean
@@ -191,4 +247,8 @@ class SecurityConfig {
 
         return roleHierarchyImpl
     }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(SecurityConfig::class.java)
+    }
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/config/SpringMvcConfig.kt

@@ -16,20 +16,29 @@
 
 package dev.usbharu.hideout.core.config
 
+import dev.usbharu.hideout.core.infrastructure.springframework.SPAInterceptor
 import dev.usbharu.hideout.generate.JsonOrFormModelMethodProcessor
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import org.springframework.http.converter.HttpMessageConverter
 import org.springframework.web.method.support.HandlerMethodArgumentResolver
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
 import org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor
 import org.springframework.web.servlet.mvc.method.annotation.ServletModelAttributeMethodProcessor
 
 @Configuration
-class MvcConfigurer(private val jsonOrFormModelMethodProcessor: JsonOrFormModelMethodProcessor) : WebMvcConfigurer {
+class MvcConfigurer(
+    private val jsonOrFormModelMethodProcessor: JsonOrFormModelMethodProcessor,
+    private val spaInterceptor: SPAInterceptor
+) : WebMvcConfigurer {
     override fun addArgumentResolvers(resolvers: MutableList<HandlerMethodArgumentResolver>) {
         resolvers.add(jsonOrFormModelMethodProcessor)
     }
+
+    override fun addInterceptors(registry: InterceptorRegistry) {
+        registry.addInterceptor(spaInterceptor)
+    }
 }
 
 @Configuration

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/event/actor/ActorEvent.kt

@@ -17,6 +17,7 @@
 package dev.usbharu.hideout.core.domain.event.actor
 
 import dev.usbharu.hideout.core.domain.model.actor.Actor
+import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEvent
 import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEventBody
 
@@ -24,13 +25,13 @@ class ActorDomainEventFactory(private val actor: Actor) {
     fun createEvent(actorEvent: ActorEvent): DomainEvent<ActorEventBody> {
         return DomainEvent.create(
             actorEvent.eventName,
-            ActorEventBody(actor),
+            ActorEventBody(actor.id),
             actorEvent.collectable
         )
     }
 }
 
-class ActorEventBody(actor: Actor) : DomainEventBody(
+class ActorEventBody(actor: ActorId) : DomainEventBody(
     mapOf(
         "actor" to actor
     ),

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/event/post/PostEvent.kt

@@ -17,7 +17,9 @@
 package dev.usbharu.hideout.core.domain.event.post
 
 import dev.usbharu.hideout.core.domain.model.actor.Actor
+import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import dev.usbharu.hideout.core.domain.model.post.Post
+import dev.usbharu.hideout.core.domain.model.post.PostId
 import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEvent
 import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEventBody
 
@@ -25,14 +27,14 @@ class PostDomainEventFactory(private val post: Post, private val actor: Actor? =
     fun createEvent(postEvent: PostEvent): DomainEvent<PostEventBody> {
         return DomainEvent.create(
             postEvent.eventName,
-            PostEventBody(post, actor)
+            PostEventBody(post.id, actor?.id)
         )
     }
 }
 
-class PostEventBody(post: Post, actor: Actor?) : DomainEventBody(mapOf("post" to post, "actor" to actor)) {
-    fun getPost(): Post = toMap()["post"] as Post
-    fun getActor(): Actor? = toMap()["actor"] as Actor?
+class PostEventBody(post: PostId, actor: ActorId?) : DomainEventBody(mapOf("post" to post, "actor" to actor)) {
+    fun getPostId(): PostId = toMap()["post"] as PostId
+    fun getActorId(): ActorId? = toMap()["actor"] as? ActorId
 }
 
 enum class PostEvent(val eventName: String) {

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/event/reaction/ReactionEvent.kt

@@ -0,0 +1,22 @@
+package dev.usbharu.hideout.core.domain.event.reaction
+
+import dev.usbharu.hideout.core.domain.model.reaction.Reaction
+import dev.usbharu.hideout.core.domain.model.reaction.ReactionId
+import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEvent
+import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEventBody
+
+class ReactionEventFactory(private val reaction: Reaction) {
+    fun createEvent(reactionEvent: ReactionEvent): DomainEvent<ReactionEventBody> =
+        DomainEvent.create(reactionEvent.eventName, ReactionEventBody(reaction))
+}
+
+class ReactionEventBody(
+    reaction: Reaction
+) : DomainEventBody(mapOf("reactionId" to reaction.id)) {
+    fun getReactionId(): ReactionId = toMap()["reactionId"] as ReactionId
+}
+
+enum class ReactionEvent(val eventName: String) {
+    CREATE("ReactionCreate"),
+    DELETE("ReactionDelete"),
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/event/relationship/RelationshipEvent.kt

@@ -31,13 +31,12 @@ class RelationshipEventBody(
     relationship: Relationship,
     override val principal: Principal
 ) : DomainEventBody(mapOf("relationship" to relationship), principal) {
-    fun getRelationship(): Relationship {
-        return toMap()["relationship"] as Relationship
-    }
+    fun getRelationship(): Relationship = toMap()["relationship"] as Relationship
 }
 
 enum class RelationshipEvent(val eventName: String) {
-    FOLLOW("RelationshipFollow"),
+    ACCEPT_FOLLOW("RelationshipFollow"),
+    REJECT_FOLLOW("RelationshipRejectFollow"),
     UNFOLLOW("RelationshipUnfollow"),
     BLOCK("RelationshipBlock"),
     UNBLOCK("RelationshipUnblock"),

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/event/timeline/TimelineEvent.kt

@@ -1,16 +1,20 @@
 package dev.usbharu.hideout.core.domain.event.timeline
 
 import dev.usbharu.hideout.core.domain.model.timeline.Timeline
+import dev.usbharu.hideout.core.domain.model.timeline.TimelineId
 import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEvent
 import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEventBody
 
 class TimelineEventFactory(private val timeline: Timeline) {
     fun createEvent(timelineEvent: TimelineEvent): DomainEvent<TimelineEventBody> =
-        DomainEvent.create(timelineEvent.eventName, TimelineEventBody(timeline))
+        DomainEvent.create(timelineEvent.eventName, TimelineEventBody(timeline.id))
 }
 
-class TimelineEventBody(timeline: Timeline) : DomainEventBody(mapOf("timeline" to timeline))
+class TimelineEventBody(timelineId: TimelineId) : DomainEventBody(mapOf("timeline" to timelineId)) {
+    fun getTimelineId(): TimelineId = toMap()["timeline"] as TimelineId
+}
 
 enum class TimelineEvent(val eventName: String) {
-    CHANGE_VISIBILITY("ChangeVisibility")
+    CHANGE_VISIBILITY("ChangeVisibility"),
+    CREATE("TimelineCreate")
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/event/userdetail/UserDetailEvent.kt

@@ -0,0 +1,27 @@
+package dev.usbharu.hideout.core.domain.event.userdetail
+
+import dev.usbharu.hideout.core.domain.model.userdetails.UserDetail
+import dev.usbharu.hideout.core.domain.model.userdetails.UserDetailId
+import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEvent
+import dev.usbharu.hideout.core.domain.shared.domainevent.DomainEventBody
+
+class UserDetailDomainEventFactory(private val userDetail: UserDetail) {
+    fun createEvent(userDetailEvent: UserDetailEvent): DomainEvent<UserDetailEventBody> {
+        return DomainEvent.create(
+            userDetailEvent.eventName,
+            UserDetailEventBody(userDetail.id)
+        )
+    }
+}
+
+class UserDetailEventBody(userDetail: UserDetailId) : DomainEventBody(
+    mapOf(
+        "userDetail" to userDetail
+    )
+) {
+    fun getUserDetail(): UserDetailId = toMap()["userDetail"] as UserDetailId
+}
+
+enum class UserDetailEvent(val eventName: String) {
+    CREATE("UserDetailCreate"),
+}

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/model/actor/Actor.kt

@@ -18,7 +18,7 @@ package dev.usbharu.hideout.core.domain.model.actor
 
 import dev.usbharu.hideout.core.domain.event.actor.ActorDomainEventFactory
 import dev.usbharu.hideout.core.domain.event.actor.ActorEvent.*
-import dev.usbharu.hideout.core.domain.model.emoji.EmojiId
+import dev.usbharu.hideout.core.domain.model.emoji.CustomEmojiId
 import dev.usbharu.hideout.core.domain.model.instance.InstanceId
 import dev.usbharu.hideout.core.domain.model.media.MediaId
 import dev.usbharu.hideout.core.domain.model.support.domain.Domain
@@ -52,7 +52,7 @@ class Actor(
     var lastUpdateAt: Instant = createdAt,
     alsoKnownAs: Set<ActorId> = emptySet(),
     moveTo: ActorId? = null,
-    emojiIds: Set<EmojiId>,
+    emojiIds: Set<CustomEmojiId>,
     deleted: Boolean,
     icon: MediaId?,
     banner: MediaId?,

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/model/emoji/CustomEmoji.kt

@@ -36,7 +36,7 @@ sealed class Emoji {
 }
 
 data class CustomEmoji(
-    val id: EmojiId,
+    val id: CustomEmojiId,
     override val name: String,
     override val domain: Domain,
     val instanceId: InstanceId,
@@ -50,6 +50,10 @@ data class CustomEmoji(
 data class UnicodeEmoji(
     override val name: String
 ) : Emoji() {
-    override val domain: Domain = Domain("unicode.org")
+    override val domain: Domain = Companion.domain
     override fun id(): String = name
+
+    companion object {
+        val domain = Domain("unicode.org")
+    }
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/model/emoji/CustomEmojiId.kt

@@ -17,7 +17,7 @@
 package dev.usbharu.hideout.core.domain.model.emoji
 
 @JvmInline
-value class EmojiId(val emojiId: Long) {
+value class CustomEmojiId(val emojiId: Long) {
     init {
         require(0 <= emojiId)
     }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/model/filter/Filter.kt

@@ -65,10 +65,7 @@ class Filter(
         return id == other.id
     }
 
-    override fun hashCode(): Int {
-        return id.hashCode()
-    }
-
+    override fun hashCode(): Int = id.hashCode()
 
     companion object {
         fun isAllow(user: UserDetail, action: Action, resource: Filter): Boolean {

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/model/filter/FilterRepository.kt

@@ -8,6 +8,5 @@ interface FilterRepository {
 
     suspend fun findByFilterKeywordId(filterKeywordId: FilterKeywordId): Filter?
     suspend fun findByFilterId(filterId: FilterId): Filter?
-
     suspend fun findByUserDetailId(userDetailId: UserDetailId): List<Filter>
 }

hideout-core/src/main/kotlin/dev/usbharu/hideout/core/domain/model/media/Media.kt

@@ -16,8 +16,10 @@
 
 package dev.usbharu.hideout.core.domain.model.media
 
+import dev.usbharu.hideout.core.domain.model.actor.ActorId
 import java.net.URI
 
+@Suppress("LongParameterList")
 class Media(
     val id: MediaId,
     val name: MediaName,
@@ -28,6 +30,7 @@ class Media(
     val mimeType: MimeType,
     val blurHash: MediaBlurHash?,
     val description: MediaDescription? = null,
+    val actorId: ActorId,
 ) {
     var url = url
         private set
@@ -35,17 +38,30 @@ class Media(
     fun setUrl(url: URI) {
         this.url = url
     }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as Media
+
+        return id == other.id
+    }
+
+    override fun hashCode(): Int = id.hashCode()
+
     override fun toString(): String {
         return "Media(" +
             "id=$id, " +
             "name=$name, " +
-            "url=$url, " +
             "remoteUrl=$remoteUrl, " +
             "thumbnailUrl=$thumbnailUrl, " +
             "type=$type, " +
             "mimeType=$mimeType, " +
             "blurHash=$blurHash, " +
-            "description=$description" +
+            "description=$description, " +
+            "actorId=$actorId, " +
+            "url=$url" +
             ")"
     }
 }