dfx 0.95.1 → 0.95.2

package/src/DiscordGateway/Shard.ts

@@ -1,14 +1,3 @@
-import * as Chunk from "effect/Chunk"
-import { GenericTag } from "effect/Context"
-import * as Duration from "effect/Duration"
-import { pipe } from "effect/Function"
-import * as Option from "effect/Option"
-import * as Secret from "effect/Secret"
-import * as Effect from "effect/Effect"
-import * as PubSub from "effect/PubSub"
-import * as Layer from "effect/Layer"
-import * as Queue from "effect/Queue"
-import * as Ref from "effect/Ref"
 import { DiscordConfig } from "dfx/DiscordConfig"
 import type { Message } from "dfx/DiscordGateway/DiscordWS"
 import {
@@ -16,13 +5,25 @@ import {
   DiscordWSLive,
   Reconnect,
 } from "dfx/DiscordGateway/DiscordWS"
+import { Messaging, MesssagingLive } from "dfx/DiscordGateway/Messaging"
+import type { ShardState } from "dfx/DiscordGateway/Shard/StateStore"
+import { ShardStateStore } from "dfx/DiscordGateway/Shard/StateStore"
 import * as Heartbeats from "dfx/DiscordGateway/Shard/heartbeats"
 import * as Identify from "dfx/DiscordGateway/Shard/identify"
-import * as InvalidSession from "dfx/DiscordGateway/Shard/invalidSession"
-import * as Utils from "dfx/DiscordGateway/Shard/utils"
-import { RateLimiterLive, RateLimiter } from "dfx/RateLimit"
+import { RateLimiter, RateLimiterLive } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
-import { Messaging, MesssagingLive } from "dfx/DiscordGateway/Messaging"
+import * as Chunk from "effect/Chunk"
+import { GenericTag } from "effect/Context"
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as PubSub from "effect/PubSub"
+import * as Queue from "effect/Queue"
+import * as Ref from "effect/Ref"
+import * as Secret from "effect/Secret"
+import type * as Types from "effect/Types"
 
 const enum Phase {
   Connecting,
@@ -35,13 +36,23 @@ export const make = Effect.gen(function* () {
   const limiter = yield* RateLimiter
   const dws = yield* DiscordWS
   const { hub, sendQueue } = yield* Messaging
+  const shardState = yield* ShardStateStore
 
   const connect = (shard: [id: number, count: number]) =>
-    Effect.gen(function* () {
+    Effect.gen(function* (_) {
       const outboundQueue = yield* Queue.unbounded<Message>()
       const pendingQueue = yield* Queue.unbounded<Message>()
       const phase = yield* Ref.make(Phase.Connecting)
-      const setPhase = (p: Phase) =>
+      const stateStore = shardState.forShard(shard)
+      const resumeState: Types.Mutable<ShardState> = Option.getOrElse(
+        yield* stateStore.get,
+        () => ({
+          resumeUrl: "",
+          sessionId: "",
+          sequence: 0,
+        }),
+      )
+      const setPhase = (p: Phase): Effect.Effect<void> =>
         Effect.zipLeft(
           Ref.set(phase, p),
           Effect.annotateLogs(Effect.logTrace("phase transition"), "phase", p),
@@ -94,29 +105,6 @@ export const make = Effect.gen(function* () {
 
       const socket = yield* dws.connect({ outbound, onConnecting })
 
-      const isReady = Option.liftPredicate(
-        (
-          p: Discord.GatewayPayload,
-        ): p is Discord.GatewayPayload<Discord.ReadyEvent> =>
-          p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
-      )
-
-      const [latestReady, updateLatestReady] = yield* Utils.latest(p =>
-        Option.map(isReady(p), p => p.d!),
-      )
-      const [latestSequence, updateLatestSequence] = yield* Utils.latest(p =>
-        Option.fromNullable(p.s),
-      )
-      const maybeUpdateUrl = (p: Discord.GatewayPayload) =>
-        Option.match(
-          Option.map(isReady(p), p => p.d!),
-          {
-            onNone: () => Effect.void,
-            onSome: ({ resume_gateway_url }) =>
-              socket.setUrl(resume_gateway_url),
-          },
-        )
-
       const hellos = yield* Effect.acquireRelease(
         Queue.unbounded<Discord.GatewayPayload>(),
         Queue.shutdown,
@@ -127,7 +115,7 @@ export const make = Effect.gen(function* () {
       )
 
       // heartbeats
-      yield* Heartbeats.send(hellos, acks, latestSequence, heartbeatSend).pipe(
+      yield* Heartbeats.send(hellos, acks, stateStore.get, heartbeatSend).pipe(
         Effect.forkScoped,
         Effect.interruptible,
       )
@@ -140,15 +128,29 @@ export const make = Effect.gen(function* () {
           intents: gateway.intents,
           presence: gateway.presence,
         },
-        latestReady,
-        latestSequence,
+        stateStore.get,
       )
 
       const onPayload = (p: Discord.GatewayPayload) =>
         pipe(
-          updateLatestReady(p),
-          Effect.zipRight(updateLatestSequence(p)),
-          Effect.zipRight(maybeUpdateUrl(p)),
+          Effect.suspend(() => {
+            if (typeof p.s === "number") {
+              resumeState.sequence = p.s
+            }
+            if (p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY") {
+              const payload = p.d as Discord.ReadyEvent
+              resumeState.sessionId = payload.session_id
+              resumeState.resumeUrl = payload.resume_gateway_url
+              return Effect.zipRight(
+                stateStore.set(resumeState),
+                socket.setUrl(payload.resume_gateway_url),
+              )
+            }
+            if (resumeState.resumeUrl !== "" && resumeState.sessionId !== "") {
+              return stateStore.set(resumeState)
+            }
+            return Effect.void
+          }),
           Effect.tap(() => {
             switch (p.op) {
               case Discord.GatewayOpcode.HELLO: {
@@ -162,10 +164,11 @@ export const make = Effect.gen(function* () {
                 return Queue.offer(acks, p)
               }
               case Discord.GatewayOpcode.INVALID_SESSION: {
-                return Effect.tap(
-                  InvalidSession.fromPayload(p, latestReady),
-                  send,
-                )
+                if (p.d) {
+                  return send(Reconnect)
+                }
+                resumeState.sessionId = ""
+                return Effect.zipRight(stateStore.clear, send(Reconnect))
               }
               case Discord.GatewayOpcode.DISPATCH: {
                 if (p.t === "READY" || p.t === "RESUMED") {

package/src/gateway.ts

@@ -3,6 +3,7 @@ import { DiscordGatewayLive } from "dfx/DiscordGateway"
 import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
 import { JsonDiscordWSCodecLive } from "dfx/DiscordGateway/DiscordWS"
 import * as Shard from "dfx/DiscordGateway/Shard"
+import { MemoryShardStateStoreLive } from "dfx/DiscordGateway/Shard/StateStore"
 import * as SendEvent from "dfx/DiscordGateway/Shard/sendEvents"
 import * as ShardStore from "dfx/DiscordGateway/ShardStore"
 import { MemoryShardStoreLive } from "dfx/DiscordGateway/ShardStore"
@@ -31,6 +32,7 @@ export const DiscordLive = Layer.mergeAll(
   Layer.provide(JsonDiscordWSCodecLive),
   Layer.provide(MemoryRateLimitStoreLive),
   Layer.provide(MemoryShardStoreLive),
+  Layer.provide(MemoryShardStateStoreLive),
 )
 
 export const DiscordIxLive = InteractionsRegistryLive.pipe(

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.95.1";
+export const LIB_VERSION = "0.95.2";

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LIB_VERSION = "0.95.1";
+export declare const LIB_VERSION = "0.95.2";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.LIB_VERSION = void 0;
-const LIB_VERSION = exports.LIB_VERSION = "0.95.1";
+const LIB_VERSION = exports.LIB_VERSION = "0.95.2";
 //# sourceMappingURL=version.js.map

package/src/DiscordGateway/Shard/invalidSession.ts

@@ -1,11 +0,0 @@
-import * as Option from "effect/Option"
-import * as Effect from "effect/Effect"
-import * as Ref from "effect/Ref"
-import { Reconnect, type Message } from "dfx/DiscordGateway/DiscordWS"
-import type * as Discord from "dfx/types"
-
-export const fromPayload = (
-  p: Discord.GatewayPayload,
-  latestReady: Ref.Ref<Option.Option<Discord.ReadyEvent>>,
-): Effect.Effect<Message> =>
-  Effect.as(p.d ? Effect.void : Ref.set(latestReady, Option.none()), Reconnect)