refactor: Event -> Payload, Payload -> Event

A bit more consistent with official terminology ^^

core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/Gateway.kt

@@ -71,9 +71,9 @@ class Gateway(
 //                if (frame !is Frame.Text && frame !is Frame.Binary)
                     return@onEach
 
-                logger.d { "Received event ${frame.readText()}" }
+                logger.d { "Received payload ${frame.readText()}" }
 
-                val raw = json.decodeFromString<Event.Unknown>(frame.readText())
+                val raw = json.decodeFromString<Payload.Unknown>(frame.readText())
                 val seq = this.seq ?: 0
                 if (seq + 1 == raw.s) {
                     this.seq = raw.s
@@ -82,33 +82,33 @@ class Gateway(
                     return@onEach
                 }
 
-                when (val msg = raw.asIncoming()) {
+                when (val payload = raw.asIncoming()) {
-                    is Event.Incoming<*> -> scope.launch { handleEvent(msg) }
+                    is Payload.Incoming<*> -> scope.launch { handlePayload(payload) }
-                    is Event.Unknown -> scope.launch { handleUnknownEvent(msg) }
+                    is Payload.Unknown -> scope.launch { handleUnknownPayload(payload) }
                 }
             }
             .launchIn(scope)
     }
 
-    suspend fun handleEvent(e: Event.Incoming<*>) {
+    suspend fun handlePayload(e: Payload.Incoming<*>) {
         logger.d { e.toString() }
-        when (val payload = e.d) {
+        when (val event = e.d) {
-            is Payload.Hello -> handleHello(payload)
+            is Event.Hello -> handleHello(event)
-            is Payload.Ready -> handlers.ready.handle(payload)
+            is Event.Ready -> handlers.ready.handle(event)
-            is Payload.Heartbeat -> {}
+            is Event.Heartbeat -> {}
-            is Payload.HeartbeatAck -> { missedBeats -= 1 }
+            is Event.HeartbeatAck -> { missedBeats -= 1 }
         }
     }
 
-    suspend fun handleUnknownEvent(e: Event.Unknown) {
+    suspend fun handleUnknownPayload(e: Payload.Unknown) {
-        logger.w { "Unknown event $e" }
+        logger.w { "Unknown payload $e" }
     }
 
-    suspend fun handleHello(e: Payload.Hello) {
+    suspend fun handleHello(e: Event.Hello) {
         val token = auth.token
             ?: throw IllegalStateException("Token missing between connection and hello, cannot send Identify")
 
-        Payload.Identify(token = token).pack().send()
+        Event.Identify(token = token).pack().send()
 
         val interval = e.heartbeatInterval.milliseconds
         scope.launch {
@@ -127,7 +127,7 @@ class Gateway(
                 resume(ResumeReason.MissedHeartbeat)
                 break
             }
-            Payload.QoSHeartbeat(this@Gateway.seq).pack().send()
+            Event.QoSHeartbeat(this@Gateway.seq).pack().send()
             missedBeats += 1
             delay(interval)
         }
@@ -160,7 +160,7 @@ class Gateway(
             is ResumeReason.MissedHeartbeat ->
                 "heartbeat missed"
             is ResumeReason.SkippedSequence ->
-                "events skipped one sequence (expected: $seq, actual: ${reason.next})"
+                "payloads skipped one sequence (expected: $seq, actual: ${reason.next})"
             is ResumeReason.CloseCode ->
                 "closed with code ${reason.code}"
             null ->
@@ -171,10 +171,10 @@ class Gateway(
         // TODO
     }
 
-    private suspend inline fun <reified T : Payload.Outgoing> Event.Outgoing<T>.send() {
+    private suspend inline fun <reified T : Event.Outgoing> Payload.Outgoing<T>.send() {
         val ws = ws
             ?: throw IllegalStateException("Tried to send with no connection")
-        logger.d { "Sending event $this" }
+        logger.d { "Sending payload $this" }
         logger.d { "Raw: ${json.encodeToString(this)}" }
         ws.send(json.encodeToString(this))
     }

core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/Payloads.kt

@@ -6,17 +6,17 @@ import kotlinx.serialization.json.JsonElement
 import moe.lava.neon.core.api.ApiConstants
 import moe.lava.neon.core.api.structures.User
 
-sealed interface Event {
+sealed interface Payload {
     val op: Int
     val d: Any?
 
-    sealed interface WithSequence : Event {
+    sealed interface WithSequence : Payload {
         val s: Int?
         val t: String?
     }
 
     @Serializable
-    data class Incoming<T : Payload.Incoming>(
+    data class Incoming<T : Event.Incoming>(
         override val op: Int,
         override val d: T,
         override val s: Int?,
@@ -24,10 +24,10 @@ sealed interface Event {
     ) : WithSequence
 
     @Serializable
-    data class Outgoing<T : Payload.Outgoing>(
+    data class Outgoing<T : Event.Outgoing>(
         override val op: Int,
         override val d: T,
-    ) : Event
+    ) : Payload
 
     @Serializable
     data class Unknown(
@@ -39,9 +39,9 @@ sealed interface Event {
 }
 
 @Serializable
-sealed interface Payload {
+sealed interface Event {
-    sealed interface Incoming : Payload
+    sealed interface Incoming : Event
-    sealed interface Outgoing : Payload
+    sealed interface Outgoing : Event
     sealed class Dispatch : Incoming
 
     // 1

core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/SerializingExtensions.kt

@@ -6,36 +6,36 @@ import moe.lava.neon.core.api.ApiConstants
 
 private val json = ApiConstants.json
 
-fun <T : Payload.Outgoing> T.pack(): Event.Outgoing<T> {
+fun <T : Event.Outgoing> T.pack(): Payload.Outgoing<T> {
     val opcode: Int = when (this) {
-        is Payload.Heartbeat -> 1
+        is Event.Heartbeat -> 1
-        is Payload.Identify -> 2
+        is Event.Identify -> 2
-        is Payload.HeartbeatAck -> 11
+        is Event.HeartbeatAck -> 11
-        is Payload.QoSHeartbeat -> 40
+        is Event.QoSHeartbeat -> 40
     }
-    return Event.Outgoing(op = opcode, d = this)
+    return Payload.Outgoing(op = opcode, d = this)
 }
 
-fun Event.Unknown.asIncoming() : Event.WithSequence {
+fun Payload.Unknown.asIncoming() : Payload.WithSequence {
     return when (op) {
         0 -> when (t) {
-            "READY" -> decode<Payload.Ready>()
+            "READY" -> decode<Event.Ready>()
             else -> this
         }
-        1 -> decode<Payload.Heartbeat>()
+        1 -> decode<Event.Heartbeat>()
-        10 -> decode<Payload.Hello>()
+        10 -> decode<Event.Hello>()
-        11 -> decode<Payload.HeartbeatAck>()
+        11 -> decode<Event.HeartbeatAck>()
         else -> this
     }
 }
 
-private inline fun <reified T : Payload.Incoming> Event.Unknown.decode(): Event.Incoming<T> =
+private inline fun <reified T : Event.Incoming> Payload.Unknown.decode(): Payload.Incoming<T> =
-    Event.Incoming(
+    Payload.Incoming(
         op = op,
         d = json.decodeFromJsonElement<T>(d!!),
         s = s,
         t = t,
     )
 
-private inline fun <reified T : Payload.Incoming> KSerializer<T>.wrap(): KSerializer<Event.Incoming<T>> =
+private inline fun <reified T : Event.Incoming> KSerializer<T>.wrap(): KSerializer<Payload.Incoming<T>> =
-    Event.Incoming.serializer(this)
+    Payload.Incoming.serializer(this)

core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/handlers/Handler.kt

@@ -1,7 +1,7 @@
 package moe.lava.neon.core.api.gateway.handlers
 
-import moe.lava.neon.core.api.gateway.Payload
+import moe.lava.neon.core.api.gateway.Event
 
-sealed interface Handler<T: Payload.Incoming> {
+sealed interface Handler<T: Event.Incoming> {
-    fun handle(payload: T)
+    fun handle(event: T)
 }

core/src/commonMain/kotlin/moe/lava/neon/core/api/gateway/handlers/ReadyHandler.kt

@@ -2,13 +2,13 @@ package moe.lava.neon.core.api.gateway.handlers
 
 import co.touchlab.kermit.Logger
 import dev.zacsweers.metro.Inject
-import moe.lava.neon.core.api.gateway.Payload
+import moe.lava.neon.core.api.gateway.Event
 
 private val logger = Logger.withTag("neon.core.api.events/ready")
 
 @Inject
-class ReadyHandler : Handler<Payload.Ready> {
+class ReadyHandler : Handler<Event.Ready> {
-    override fun handle(payload: Payload.Ready) {
+    override fun handle(event: Event.Ready) {
-        logger.i { "Received payload $payload" }
+        logger.i { "Received payload $event" }
     }
 }