dfx 0.127.0 → 1.0.1

package/src/DiscordGateway/Shard/StateStore.ts

@@ -1,8 +1,9 @@
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import * as Context from "effect/Context"
 import * as Layer from "effect/Layer"
-import * as KVS from "@effect/platform/KeyValueStore"
+import * as ServiceMap from "effect/ServiceMap"
+import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore"
+import { flow, pipe } from "effect/Function"
 
 export interface ShardState {
   readonly resumeUrl: string
@@ -16,10 +17,10 @@ export interface StateStore {
   readonly clear: Effect.Effect<void>
 }
 
-export class ShardStateStore extends Context.Tag("dfx/Shard/StateStore")<
+export class ShardStateStore extends ServiceMap.Service<
   ShardStateStore,
   { readonly forShard: (id: [id: number, count: number]) => StateStore }
->() {
+>()("dfx/Shard/StateStore") {
   static MemoryLive: Layer.Layer<ShardStateStore> = Layer.sync(
     ShardStateStore,
     () => {
@@ -29,7 +30,7 @@ export class ShardStateStore extends Context.Tag("dfx/Shard/StateStore")<
         forShard: ([id, count]) => {
           const key = `${id}-${count}`
           return {
-            get: Effect.sync(() => Option.fromNullable(store.get(key))),
+            get: Effect.sync(() => Option.fromUndefinedOr(store.get(key))),
             set(state) {
               return Effect.sync(() => {
                 store.set(key, state)
@@ -44,24 +45,28 @@ export class ShardStateStore extends Context.Tag("dfx/Shard/StateStore")<
     },
   )
 
-  static KVSLive: Layer.Layer<ShardStateStore, never, KVS.KeyValueStore> =
-    Layer.effect(
-      ShardStateStore,
-      Effect.gen(function* () {
-        const store = yield* KVS.KeyValueStore
-        return ShardStateStore.of({
-          forShard([id, count]) {
-            const key = `dfx-shard-state-${id}-${count}`
-            return {
-              get: Effect.map(
-                Effect.orDie(store.get(key)),
-                Option.map(JSON.parse),
-              ),
-              set: state => Effect.orDie(store.set(key, JSON.stringify(state))),
-              clear: Effect.orDie(store.remove(key)),
-            }
-          },
-        })
-      }),
-    )
+  static KVSLive: Layer.Layer<
+    ShardStateStore,
+    never,
+    KeyValueStore.KeyValueStore
+  > = Layer.effect(
+    ShardStateStore,
+    Effect.gen(function* () {
+      const store = yield* KeyValueStore.KeyValueStore
+      return ShardStateStore.of({
+        forShard([id, count]) {
+          const key = `dfx-shard-state-${id}-${count}`
+          return {
+            get: pipe(
+              store.get(key),
+              Effect.orDie,
+              Effect.map(flow(Option.fromUndefinedOr, Option.map(JSON.parse))),
+            ),
+            set: state => Effect.orDie(store.set(key, JSON.stringify(state))),
+            clear: Effect.orDie(store.remove(key)),
+          }
+        },
+      })
+    }),
+  )
 }

package/src/DiscordGateway/Shard/heartbeats.ts

@@ -1,18 +1,18 @@
-import * as Duration from "effect/Duration"
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as Ref from "effect/Ref"
-import * as Schedule from "effect/Schedule"
-import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
-import * as SendEvents from "dfx/DiscordGateway/Shard/sendEvents"
-import type * as Discord from "dfx/types"
-import * as EffectU from "dfx/utils/Effect"
-import type { ShardState } from "dfx/DiscordGateway/Shard/StateStore"
-import type * as Mailbox from "effect/Mailbox"
+import * as DiscordWS from "../DiscordWS.ts"
+import * as SendEvents from "./sendEvents.ts"
+import type * as Discord from "../../types.ts"
+import * as EffectU from "../../utils/Effect.ts"
+import type { ShardState } from "./StateStore.ts"
+import * as Queue from "effect/Queue"
 
 const payload = (state: Effect.Effect<Option.Option<ShardState>>) =>
-  Effect.map(state, state =>
-    SendEvents.heartbeat(Option.getOrNull(Option.map(state, s => s.sequence))),
+  Effect.map(state, shardState =>
+    SendEvents.heartbeat(
+      Option.getOrNull(Option.map(shardState, s => s.sequence)),
+    ),
   )
 
 const payloadOrReconnect = (
@@ -26,33 +26,30 @@ const payloadOrReconnect = (
   )
 
 export const send = (
-  hellos: Mailbox.ReadonlyMailbox<Discord.GatewayHelloData>,
-  acks: Mailbox.ReadonlyMailbox<void>,
+  hellos: Queue.Dequeue<Discord.GatewayHelloData>,
+  acks: Queue.Dequeue<void>,
   state: Effect.Effect<Option.Option<ShardState>>,
-  send: (p: DiscordWS.MessageSend) => Effect.Effect<void>,
+  sendMessage: (p: DiscordWS.MessageSend) => Effect.Effect<void>,
 ) =>
   Effect.flatMap(Ref.make(true), ackedRef => {
     const sendPayload = payloadOrReconnect(ackedRef, state).pipe(
-      Effect.zipLeft(Ref.set(ackedRef, false)),
-      Effect.flatMap(send),
+      Effect.tap(Ref.set(ackedRef, false)),
+      Effect.flatMap(sendMessage),
     )
 
     const heartbeats = EffectU.foreverSwitch(
-      Effect.zipLeft(hellos.take, Ref.set(ackedRef, true)),
-      p =>
-        Effect.schedule(
-          sendPayload,
-          Schedule.andThen(
-            Schedule.duration(
-              Duration.millis(p.heartbeat_interval * Math.random()),
-            ),
-            Schedule.spaced(Duration.millis(p.heartbeat_interval)),
-          ),
-        ),
+      Effect.tap(Queue.take(hellos), Ref.set(ackedRef, true)),
+      Effect.fnUntraced(function* (p) {
+        yield* Effect.sleep(p.heartbeat_interval * Math.random())
+        while (true) {
+          yield* sendPayload
+          yield* Effect.sleep(p.heartbeat_interval)
+        }
+      }),
     )
 
-    const run = acks.take.pipe(
-      Effect.zipLeft(Ref.set(ackedRef, true)),
+    const run = Queue.take(acks).pipe(
+      Effect.tap(Ref.set(ackedRef, true)),
       Effect.forever,
     )
 

package/src/DiscordGateway/Shard/identify.ts

@@ -1,8 +1,8 @@
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
-import * as SendEvents from "dfx/DiscordGateway/Shard/sendEvents"
-import type * as Discord from "dfx/types"
-import type { ShardState } from "dfx/DiscordGateway/Shard/StateStore"
+import * as SendEvents from "./sendEvents.ts"
+import type * as Discord from "../../types.ts"
+import type { ShardState } from "./StateStore.ts"
 
 declare const process: { platform?: string | undefined } | undefined
 
@@ -44,6 +44,7 @@ export const identifyOrResume = (
     state,
     Option.match({
       onNone: () => identify(opts),
-      onSome: state => resume(opts.token, state.sessionId, state.sequence),
+      onSome: shardState =>
+        resume(opts.token, shardState.sessionId, shardState.sequence),
     }),
   )

package/src/DiscordGateway/Shard/sendEvents.ts

@@ -1,4 +1,4 @@
-import * as Discord from "dfx/types"
+import * as Discord from "../../types.ts"
 
 export const heartbeat = (
   d: Discord.GatewayHeartbeatData,

package/src/DiscordGateway/Shard/utils.ts

@@ -1,4 +1,4 @@
-import type * as Discord from "dfx/types"
+import type * as Discord from "../../types.ts"
 import * as Stream from "effect/Stream"
 
 export const opCode =

package/src/DiscordGateway/Shard.ts

@@ -1,27 +1,26 @@
-import { DiscordConfig } from "dfx/DiscordConfig"
-import type { MessageSend } from "dfx/DiscordGateway/DiscordWS"
-import {
-  DiscordWS,
-  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 { RateLimiter, RateLimiterLive } from "dfx/RateLimit"
-import * as Discord from "dfx/types"
-import { GenericTag } from "effect/Context"
+import { DiscordConfig } from "../DiscordConfig.ts"
+import type { MessageSend } from "./DiscordWS.ts"
+import { DiscordWS, DiscordWSLive, Reconnect } from "./DiscordWS.ts"
+import { Messaging, MesssagingLive } from "./Messaging.ts"
+import type { ShardState } from "./Shard/StateStore.ts"
+import { ShardStateStore } from "./Shard/StateStore.ts"
+import * as Heartbeats from "./Shard/heartbeats.ts"
+import * as Identify from "./Shard/identify.ts"
+import { RateLimiter, RateLimiterLive } from "../RateLimit.ts"
+import * as Discord from "../types.ts"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
-import * as Mailbox from "effect/Mailbox"
 import * as Redacted from "effect/Redacted"
 import type * as Types from "effect/Types"
 import * as FiberHandle from "effect/FiberHandle"
 import { constant, constTrue, constVoid } from "effect/Function"
+import * as Queue from "effect/Queue"
+import * as ServiceMap from "effect/ServiceMap"
+import * as PubSub from "effect/PubSub"
+import * as LogLevel from "effect/LogLevel"
+import { MinimumLogLevel } from "effect/References"
 
 const enum Phase {
   Connecting,
@@ -38,6 +37,10 @@ export const make = Effect.gen(function* () {
 
   const connect = Effect.fnUntraced(
     function* (shard: [id: number, count: number]) {
+      const traceEnabled = LogLevel.isLessThanOrEqualTo(
+        yield* MinimumLogLevel,
+        "Trace",
+      )
       const reconnectHandle = yield* FiberHandle.make()
       let phase = Phase.Connecting
       const stateStore = shardState.forShard(shard)
@@ -52,6 +55,7 @@ export const make = Effect.gen(function* () {
       const setPhase = (p: Phase): Effect.Effect<void> =>
         Effect.suspend(() => {
           phase = p
+          if (!traceEnabled) return Effect.void
           return Effect.annotateLogs(
             Effect.logTrace("phase transition"),
             "phase",
@@ -65,7 +69,7 @@ export const make = Effect.gen(function* () {
           return write(p)
         })
 
-      const resume = Effect.zipRight(
+      const resume = Effect.andThen(
         FiberHandle.clear(reconnectHandle),
         setPhase(Phase.Connected),
       )
@@ -74,18 +78,18 @@ export const make = Effect.gen(function* () {
 
       const socket = yield* dws.connect({ onConnecting })
       const write = (p: MessageSend) =>
-        Effect.zipRight(
+        Effect.andThen(
           limiter.maybeWait("dfx.shard.send", Duration.minutes(1), 120),
           socket.write(p),
         )
 
       const hellos = yield* Effect.acquireRelease(
-        Mailbox.make<Discord.GatewayHelloData>(),
-        _ => _.shutdown,
+        Queue.make<Discord.GatewayHelloData>(),
+        Queue.shutdown,
       )
       const acks = yield* Effect.acquireRelease(
-        Mailbox.make<void>(),
-        _ => _.shutdown,
+        Queue.make<void>(),
+        Queue.shutdown,
       )
 
       // heartbeats
@@ -129,12 +133,12 @@ export const make = Effect.gen(function* () {
           case Discord.GatewayOpcodes.Hello: {
             yield* write(yield* identify)
             yield* setPhase(Phase.Handshake)
-            hellos.unsafeOffer(p.d)
+            Queue.offerUnsafe(hellos, p.d)
             yield* FiberHandle.run(reconnectHandle, delayedReconnect)
             return
           }
           case Discord.GatewayOpcodes.HeartbeatAck: {
-            acks.unsafeOffer(void 0)
+            Queue.offerUnsafe(acks, void 0)
             return
           }
           case Discord.GatewayOpcodes.InvalidSession: {
@@ -149,7 +153,7 @@ export const make = Effect.gen(function* () {
             if (p.t === "READY" || p.t === "RESUMED") {
               yield* resume
             }
-            hub.unsafeOffer(p)
+            PubSub.publishUnsafe(hub, p)
             return
           }
           case Discord.GatewayOpcodes.Reconnect: {
@@ -161,15 +165,15 @@ export const make = Effect.gen(function* () {
 
       yield* Effect.whileLoop({
         while: constTrue,
-        body: constant(Effect.flatMap(sendMailbox.take, write)),
+        body: constant(Effect.flatMap(Queue.take(sendMailbox), write)),
         step: constVoid,
-      }).pipe(Effect.forkScoped, Effect.interruptible)
+      }).pipe(Effect.forkScoped)
 
       yield* Effect.gen(function* () {
         while (true) {
           yield* onPayload(yield* socket.take)
         }
-      }).pipe(Effect.forkScoped, Effect.interruptible)
+      }).pipe(Effect.forkScoped)
 
       return { id: shard, write } as const
     },
@@ -184,12 +188,11 @@ export const make = Effect.gen(function* () {
   return { connect } as const
 })
 
-type ShardService = Effect.Effect.Success<typeof make>
+type ShardService = Effect.Success<typeof make>
 
-export interface Shard {
-  readonly _: unique symbol
-}
-export const Shard = GenericTag<Shard, ShardService>("dfx/DiscordGateway/Shard")
+export class Shard extends ServiceMap.Service<Shard, ShardService>()(
+  "dfx/DiscordGateway/Shard",
+) {}
 export const ShardLive = Layer.effect(Shard, make).pipe(
   Layer.provide(DiscordWSLive),
   Layer.provide(MesssagingLive),
@@ -197,5 +200,6 @@ export const ShardLive = Layer.effect(Shard, make).pipe(
 )
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface RunningShard
-  extends Effect.Effect.Success<ReturnType<ShardService["connect"]>> {}
+export interface RunningShard extends Effect.Success<
+  ReturnType<ShardService["connect"]>
+> {}

package/src/DiscordGateway/ShardStore.ts

@@ -1,7 +1,7 @@
-import { GenericTag } from "effect/Context"
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as ServiceMap from "effect/ServiceMap"
 
 export interface ClaimIdContext {
   sharderCount: number
@@ -13,12 +13,11 @@ export interface ShardStoreService {
   allClaimed: (totalCount: number) => Effect.Effect<boolean>
   heartbeat?: (shardId: number) => Effect.Effect<void>
 }
-export interface ShardStore {
-  readonly _: unique symbol
-}
-export const ShardStore = GenericTag<ShardStore, ShardStoreService>(
-  "dfx/DiscordGateway/ShardStore",
-)
+
+export class ShardStore extends ServiceMap.Service<
+  ShardStore,
+  ShardStoreService
+>()("dfx/DiscordGateway/ShardStore") {}
 
 // Very basic shard id store, that does no health checks
 const memoryStore = (): ShardStoreService => {

package/src/DiscordGateway/Sharder.ts

@@ -1,11 +1,10 @@
-import { DiscordConfig } from "dfx/DiscordConfig"
-import type { RunningShard } from "dfx/DiscordGateway/Shard"
-import { Shard, ShardLive } from "dfx/DiscordGateway/Shard"
-import { ShardStore } from "dfx/DiscordGateway/ShardStore"
-import { DiscordREST, DiscordRESTLive } from "dfx/DiscordREST"
-import { RateLimiter, RateLimiterLive } from "dfx/RateLimit"
-import type * as Discord from "dfx/types"
-import { GenericTag } from "effect/Context"
+import { DiscordConfig } from "../DiscordConfig.ts"
+import type { RunningShard } from "./Shard.ts"
+import { Shard, ShardLive } from "./Shard.ts"
+import { ShardStore } from "./ShardStore.ts"
+import { DiscordREST, DiscordRESTLive } from "../DiscordREST.ts"
+import { RateLimiter, RateLimiterLive } from "../RateLimit.ts"
+import type * as Discord from "../types.ts"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
@@ -13,23 +12,25 @@ import * as Layer from "effect/Layer"
 import type * as Option from "effect/Option"
 import * as Ref from "effect/Ref"
 import * as Schedule from "effect/Schedule"
+import * as ServiceMap from "effect/ServiceMap"
 
-const claimRepeatPolicy = Schedule.spaced("3 minutes").pipe(
-  Schedule.whileInput((_: Option.Option<number>) => _._tag === "None"),
+const claimRepeatPolicy = Schedule.identity<Option.Option<number>>().pipe(
+  Schedule.either(Schedule.spaced("3 minutes")),
+  Schedule.while(_ => Effect.succeed(_.input._tag === "None")),
   Schedule.passthrough,
 ) as Schedule.Schedule<Option.Some<number>, Option.Option<number>>
 
 const make = Effect.gen(function* () {
   const store = yield* ShardStore
   const rest = yield* DiscordREST
-  const { gateway: config } = yield* DiscordConfig
+  const { gateway: gatewayConfig } = yield* DiscordConfig
   const limiter = yield* RateLimiter
   const shard = yield* Shard
   const currentShards = new Set<RunningShard>()
 
   const gateway = yield* rest.getBotGateway().pipe(
-    Effect.catchAll(() =>
-      Effect.succeed<Discord.GatewayBotResponse>({
+    Effect.catch(() =>
+      Effect.succeed<Discord.APIGatewayBotInfo>({
         url: "wss://gateway.discord.gg/",
         shards: 1,
         session_start_limit: {
@@ -42,7 +43,7 @@ const make = Effect.gen(function* () {
     ),
   )
 
-  const totalCount = config.shardCount ?? gateway.shards
+  const totalCount = gatewayConfig.shardCount ?? gateway.shards
   const currentCount = yield* Ref.make(0)
   const claimId = (sharderCount: number): Effect.Effect<number> =>
     pipe(
@@ -61,21 +62,22 @@ const make = Effect.gen(function* () {
 
   const spawner = pipe(
     takeConfig,
-    Effect.map(config => ({
-      ...config,
+    Effect.map(shardConfig => ({
+      ...shardConfig,
       url: gateway.url,
       concurrency: gateway.session_start_limit.max_concurrency,
     })),
     Effect.tap(({ concurrency, id }) =>
       limiter.maybeWait(
         `dfx.sharder.${id % concurrency}`,
-        Duration.millis(config.identifyRateLimit[0]),
-        config.identifyRateLimit[1],
+        Duration.millis(gatewayConfig.identifyRateLimit[0]),
+        gatewayConfig.identifyRateLimit[1],
       ),
     ),
     Effect.flatMap(c => shard.connect([c.id, c.totalCount])),
-    Effect.tap(shard => {
-      currentShards.add(shard)
+    Effect.tap(runningShard => {
+      currentShards.add(runningShard)
+      return Effect.void
     }),
     Effect.forever,
   )
@@ -86,11 +88,10 @@ const make = Effect.gen(function* () {
     { concurrency: "unbounded", discard: true },
   ).pipe(
     Effect.scoped,
-    Effect.catchAllCause(Effect.logError),
+    Effect.catchCause(Effect.logError),
     Effect.ensuring(Effect.sync(() => currentShards.clear())),
     Effect.forever,
     Effect.forkScoped,
-    Effect.interruptible,
   )
 
   return {
@@ -103,13 +104,14 @@ const make = Effect.gen(function* () {
   }),
 )
 
-export interface Sharder {
-  readonly _: unique symbol
-}
-export const Sharder = GenericTag<Sharder, Effect.Effect.Success<typeof make>>(
-  "dfx/DiscordGateway/Sharder",
-)
-export const SharderLive = Layer.scoped(Sharder, make).pipe(
+export class Sharder extends ServiceMap.Service<
+  Sharder,
+  {
+    readonly shards: Effect.Effect<ReadonlySet<RunningShard>, never, never>
+  }
+>()("dfx/DiscordGateway/Sharder") {}
+
+export const SharderLive = Layer.effect(Sharder, make).pipe(
   Layer.provide(DiscordRESTLive),
   Layer.provide(RateLimiterLive),
   Layer.provide(ShardLive),

package/src/DiscordGateway.ts

@@ -1,19 +1,19 @@
-import type { HttpClient } from "@effect/platform/HttpClient"
-import type { WebSocketConstructor } from "@effect/platform/Socket"
-import type { DiscordConfig } from "dfx/DiscordConfig"
-import type { DiscordWSCodec } from "dfx/DiscordGateway/DiscordWS"
-import type { Messsaging } from "dfx/DiscordGateway/Messaging"
-import { Messaging, MesssagingLive } from "dfx/DiscordGateway/Messaging"
-import type { RunningShard } from "dfx/DiscordGateway/Shard"
-import type { ShardStateStore } from "dfx/DiscordGateway/Shard/StateStore"
-import { Sharder, SharderLive } from "dfx/DiscordGateway/Sharder"
-import type { ShardStore } from "dfx/DiscordGateway/ShardStore"
-import type { RateLimitStore } from "dfx/RateLimit"
-import type * as Discord from "dfx/types"
-import { GenericTag } from "effect/Context"
+import type { WebSocketConstructor } from "effect/unstable/socket/Socket"
+import type { DiscordConfig } from "./DiscordConfig.ts"
+import type { DiscordWSCodec } from "./DiscordGateway/DiscordWS.ts"
+import type { Messsaging } from "./DiscordGateway/Messaging.ts"
+import { Messaging, MesssagingLive } from "./DiscordGateway/Messaging.ts"
+import type { RunningShard } from "./DiscordGateway/Shard.ts"
+import type { ShardStateStore } from "./DiscordGateway/Shard/StateStore.ts"
+import { Sharder, SharderLive } from "./DiscordGateway/Sharder.ts"
+import type { ShardStore } from "./DiscordGateway/ShardStore.ts"
+import type { RateLimitStore } from "./RateLimit.ts"
+import type * as Discord from "./types.ts"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import type * as Stream from "effect/Stream"
+import type { HttpClient } from "effect/unstable/http/HttpClient"
+import * as ServiceMap from "effect/ServiceMap"
 
 export const TypeId = Symbol.for("dfx/DiscordGateway")
 export type TypeId = typeof TypeId
@@ -45,7 +45,8 @@ export interface DiscordGateway {
   readonly shards: Effect.Effect<ReadonlySet<RunningShard>>
 }
 
-export const DiscordGateway = GenericTag<DiscordGateway>("dfx/DiscordGateway")
+export const DiscordGateway =
+  ServiceMap.Service<DiscordGateway>("dfx/DiscordGateway")
 
 export const make: Effect.Effect<DiscordGateway, never, Messsaging | Sharder> =
   Effect.gen(function* () {