dfx 0.126.1 → 1.0.0

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* () {