dfx 0.60.0 → 0.61.1

package/src/Cache/prelude.ts

@@ -32,17 +32,19 @@ export const opsWithParent = <E, T>({
   remove,
   update,
 }: OptsWithParentOptions<E, T>) => {
-  const fromParentOps = Stream.flatMap(fromParent, ([parentId, a]) =>
-    Stream.fromIterable(
-      a.map(
-        (resource): ParentCacheOp<T> => ({
-          op: "create",
-          parentId,
-          resourceId: id(resource),
-          resource,
-        }),
+  const fromParentOps = Stream.flatMap(
+    fromParent,
+    ([parentId, a]) =>
+      Stream.fromIterable(
+        a.map(
+          (resource): ParentCacheOp<T> => ({
+            op: "create",
+            parentId,
+            resourceId: id(resource),
+            resource,
+          }),
+        ),
       ),
-    ),
   )
 
   const createOps = Stream.map(
@@ -129,7 +131,7 @@ export const ops = <E, T>({ create, id, remove, update }: OpsOptions<E, T>) => {
 export const guilds = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, CacheDriver<E, Discord.Guild>>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
     const rest = yield* _(DiscordREST)
@@ -156,7 +158,7 @@ export const guilds = <RM, EM, E>(
 export const channels = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Channel>>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
     const rest = yield* _(DiscordREST)
@@ -199,7 +201,7 @@ export const channels = <RM, EM, E>(
 export const roles = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Role>>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
     const rest = yield* _(DiscordREST)

package/src/Cache.ts

@@ -1,7 +1,7 @@
-import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
-import * as Effect from "@effect/io/Effect"
 import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
 import * as Stream from "@effect/stream/Stream"
+import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
 
 export * from "dfx/Cache/driver"
 export {
@@ -97,7 +97,7 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
                 Effect.all(
                   entries.map(([id, a]) => driver.set(parentId, id, a)),
                   { concurrency: "unbounded" },
-                ),
+                )
               ),
               Effect.map(entries => new Map(entries) as ReadonlyMap<string, A>),
             ),

package/src/DiscordGateway/DiscordWS.ts

@@ -1,10 +1,10 @@
-import { LiveWS, Reconnect, WS } from "dfx/DiscordGateway/WS"
-import type WebSocket from "isomorphic-ws"
-import type * as Discord from "dfx/types"
+import { Tag } from "@effect/data/Context"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
-import { Tag } from "@effect/data/Context"
 import * as Ref from "@effect/io/Ref"
+import { LiveWS, Reconnect, WS } from "dfx/DiscordGateway/WS"
+import type * as Discord from "dfx/types"
+import type WebSocket from "isomorphic-ws"
 
 export type Message = Discord.GatewayPayload | Reconnect
 
@@ -28,7 +28,7 @@ export const LiveJsonDiscordWSCodec = Layer.succeed(DiscordWSCodec, {
   decode: p => JSON.parse(p.toString("utf8")),
 })
 
-const make = Effect.gen(function* (_) {
+const make = Effect.gen(function*(_) {
   const ws = yield* _(WS)
   const encoding = yield* _(DiscordWSCodec)
 
@@ -38,23 +38,22 @@ const make = Effect.gen(function* (_) {
     url = "wss://gateway.discord.gg/",
     version = 10,
   }: OpenOpts) =>
-    Effect.gen(function* (_) {
+    Effect.gen(function*(_) {
       const urlRef = yield* _(
         Ref.make(`${url}?v=${version}&encoding=${encoding.type}`),
       )
       const setUrl = (url: string) =>
         Ref.set(urlRef, `${url}?v=${version}&encoding=${encoding.type}`)
       const takeOutbound = Effect.map(outbound, msg =>
-        msg === Reconnect ? msg : encoding.encode(msg),
-      )
+        msg === Reconnect ? msg : encoding.encode(msg))
       const socket = yield* _(ws.connect(urlRef, takeOutbound, onConnecting))
       const take = Effect.map(socket.take, encoding.decode)
 
       const run = Effect.retryWhile(
         socket.run,
         e =>
-          (e._tag === "WebSocketCloseError" && e.code < 2000) ||
-          (e._tag === "WebSocketError" && e.reason === "open-timeout"),
+          (e._tag === "WebSocketCloseError" && e.code < 2000)
+          || (e._tag === "WebSocketError" && e.reason === "open-timeout"),
       )
 
       return {

package/src/DiscordGateway/Shard/heartbeats.ts

@@ -35,7 +35,7 @@ export const send = (
   seqRef: Ref.Ref<Option.Option<number>>,
   send: (p: DiscordWS.Message) => Effect.Effect<never, never, boolean>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const ackedRef = yield* _(Ref.make(true))
 
     const heartbeats = EffectU.foreverSwitch(

package/src/DiscordGateway/Shard/utils.ts

@@ -1,8 +1,8 @@
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import * as Ref from "@effect/io/Ref"
-import type * as Discord from "dfx/types"
 import * as Stream from "@effect/stream/Stream"
+import type * as Discord from "dfx/types"
 
 export const opCode =
   <R, E>(source: Stream.Stream<R, E, Discord.GatewayPayload>) =>
@@ -13,16 +13,15 @@ export const opCode =
       Stream.filter((p): p is Discord.GatewayPayload<T> => p.op === code),
     )
 
-const maybeUpdateRef =
-  <T>(
-    f: (p: Discord.GatewayPayload) => Option.Option<T>,
-    ref: Ref.Ref<Option.Option<T>>,
-  ) =>
-  (_: Discord.GatewayPayload): Effect.Effect<never, never, void> =>
-    Option.match(f(_), {
-      onNone: () => Effect.unit,
-      onSome: a => Ref.set(ref, Option.some(a)),
-    })
+const maybeUpdateRef = <T>(
+  f: (p: Discord.GatewayPayload) => Option.Option<T>,
+  ref: Ref.Ref<Option.Option<T>>,
+) =>
+(_: Discord.GatewayPayload): Effect.Effect<never, never, void> =>
+  Option.match(f(_), {
+    onNone: () => Effect.unit,
+    onSome: a => Ref.set(ref, Option.some(a)),
+  })
 
 export const latest = <T>(
   f: (p: Discord.GatewayPayload) => Option.Option<T>,
@@ -36,6 +35,5 @@ export const latest = <T>(
 > =>
   Effect.map(
     Ref.make<Option.Option<T>>(Option.none()),
-
     ref => [ref, maybeUpdateRef(f, ref)] as const,
   )

package/src/DiscordGateway/Shard.ts

@@ -1,5 +1,14 @@
+import * as Chunk from "@effect/data/Chunk"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import * as Option from "@effect/data/Option"
+import * as ConfigSecret from "@effect/io/Config/Secret"
+import * as Effect from "@effect/io/Effect"
+import * as Hub from "@effect/io/Hub"
+import * as Layer from "@effect/io/Layer"
+import * as Queue from "@effect/io/Queue"
+import * as Ref from "@effect/io/Ref"
 import { DiscordConfig } from "dfx/DiscordConfig"
-import { LiveRateLimiter, RateLimiter } from "dfx/RateLimit"
 import type { Message } from "dfx/DiscordGateway/DiscordWS"
 import { DiscordWS, LiveDiscordWS } from "dfx/DiscordGateway/DiscordWS"
 import * as Heartbeats from "dfx/DiscordGateway/Shard/heartbeats"
@@ -8,17 +17,8 @@ import * as InvalidSession from "dfx/DiscordGateway/Shard/invalidSession"
 import * as Utils from "dfx/DiscordGateway/Shard/utils"
 import { Reconnect } from "dfx/DiscordGateway/WS"
 import { Log } from "dfx/Log"
+import { LiveRateLimiter, RateLimiter } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
-import * as Effect from "@effect/io/Effect"
-import * as Layer from "@effect/io/Layer"
-import { Tag } from "@effect/data/Context"
-import * as Option from "@effect/data/Option"
-import * as Hub from "@effect/io/Hub"
-import * as Queue from "@effect/io/Queue"
-import * as Ref from "@effect/io/Ref"
-import * as Duration from "@effect/data/Duration"
-import * as Chunk from "@effect/data/Chunk"
-import * as ConfigSecret from "@effect/io/Config/Secret"
 
 const enum Phase {
   Connecting,
@@ -26,7 +26,7 @@ const enum Phase {
   Connected,
 }
 
-export const make = Effect.gen(function* (_) {
+export const make = Effect.gen(function*(_) {
   const { gateway, token } = yield* _(DiscordConfig)
   const limiter = yield* _(RateLimiter)
   const dws = yield* _(DiscordWS)
@@ -37,7 +37,7 @@ export const make = Effect.gen(function* (_) {
     hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
     sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
   ) =>
-    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))
@@ -52,15 +52,13 @@ export const make = Effect.gen(function* (_) {
         Effect.flatMap(Ref.get(phase), phase =>
           phase === Phase.Connected
             ? Queue.offer(outboundQueue, p)
-            : Queue.offer(pendingQueue, p),
-        )
+            : Queue.offer(pendingQueue, p))
 
       const heartbeatSend = (p: Message) =>
         Effect.flatMap(Ref.get(phase), phase =>
           phase !== Phase.Connecting
             ? Queue.offer(outboundQueue, p)
-            : Effect.succeed(false),
-        )
+            : Effect.succeed(false))
 
       const prioritySend = (p: Message) => Queue.offer(outboundQueue, p)
 
@@ -77,12 +75,12 @@ export const make = Effect.gen(function* (_) {
             Chunk.filter(
               msgs,
               msg =>
-                msg !== Reconnect &&
-                msg.op !== Discord.GatewayOpcode.IDENTIFY &&
-                msg.op !== Discord.GatewayOpcode.RESUME &&
-                msg.op !== Discord.GatewayOpcode.HEARTBEAT,
+                msg !== Reconnect
+                && msg.op !== Discord.GatewayOpcode.IDENTIFY
+                && msg.op !== Discord.GatewayOpcode.RESUME
+                && msg.op !== Discord.GatewayOpcode.HEARTBEAT,
             ),
-          ),
+          )
         ),
         Effect.zipRight(setPhase(Phase.Connecting)),
       )
@@ -97,7 +95,7 @@ export const make = Effect.gen(function* (_) {
                 p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
             ),
             Option.map(p => p.d!),
-          ),
+          )
         ),
       )
       const [latestSequence, updateLatestSequence] = yield* _(
@@ -198,4 +196,5 @@ export const LiveShard = Layer.provide(
 )
 
 export interface RunningShard
-  extends Effect.Effect.Success<ReturnType<Shard["connect"]>> {}
+  extends Effect.Effect.Success<ReturnType<Shard["connect"]>>
+{}

package/src/DiscordGateway/ShardStore.ts

@@ -1,7 +1,7 @@
-import * as Effect from "@effect/io/Effect"
-import * as Layer from "@effect/io/Layer"
 import { Tag } from "@effect/data/Context"
 import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
 
 export interface ClaimIdContext {
   sharderCount: number

package/src/DiscordGateway/Sharder.ts

@@ -24,7 +24,7 @@ const claimRepeatPolicy = Schedule.fixed("3 minutes").pipe(
   Schedule.passthrough,
 ) as Schedule.Schedule<never, Option.Option<number>, Option.Some<number>>
 
-const make = Effect.gen(function* (_) {
+const make = Effect.gen(function*(_) {
   const store = yield* _(ShardStore)
   const rest = yield* _(DiscordREST)
   const { gateway: config } = yield* _(DiscordConfig)
@@ -33,7 +33,7 @@ const make = Effect.gen(function* (_) {
   const currentShards = yield* _(Ref.make(HashSet.empty<RunningShard>()))
 
   const takeConfig = (totalCount: number) =>
-    Effect.gen(function* (_) {
+    Effect.gen(function*(_) {
       const currentCount = yield* _(Ref.make(0))
 
       const claimId = (
@@ -68,7 +68,7 @@ const make = Effect.gen(function* (_) {
           reset_after: 0,
           max_concurrency: 1,
         },
-      }),
+      })
     ),
   )
 
@@ -76,7 +76,7 @@ const make = Effect.gen(function* (_) {
     hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
     sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
   ) =>
-    Effect.gen(function* (_) {
+    Effect.gen(function*(_) {
       const deferred = yield* _(
         Deferred.make<WebSocketError | WebSocketCloseError, never>(),
       )
@@ -93,10 +93,10 @@ const make = Effect.gen(function* (_) {
             `dfx.sharder.${id % concurrency}`,
             Duration.millis(config.identifyRateLimit[0]),
             config.identifyRateLimit[1],
-          ),
+          )
         ),
         Effect.flatMap(c =>
-          shard.connect([c.id, c.totalCount], hub, sendQueue),
+          shard.connect([c.id, c.totalCount], hub, sendQueue)
         ),
         Effect.flatMap(shard =>
           Effect.acquireUseRelease(
@@ -106,7 +106,7 @@ const make = Effect.gen(function* (_) {
           ).pipe(
             Effect.catchAllCause(_ => Deferred.failCause(deferred, _)),
             Effect.fork,
-          ),
+          )
         ),
         Effect.forever,
       )

package/src/DiscordGateway/WS.ts

@@ -1,12 +1,12 @@
-import { Log } from "dfx/Log"
-import WebSocket from "isomorphic-ws"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
-import { Tag } from "@effect/data/Context"
-import * as Ref from "@effect/io/Ref"
 import * as Queue from "@effect/io/Queue"
+import * as Ref from "@effect/io/Ref"
 import * as Runtime from "@effect/io/Runtime"
-import * as Duration from "@effect/data/Duration"
+import { Log } from "dfx/Log"
+import WebSocket from "isomorphic-ws"
 
 export const Reconnect = Symbol()
 export type Reconnect = typeof Reconnect
@@ -38,7 +38,7 @@ const socket = (urlRef: Ref.Ref<string>) =>
         // eslint-disable-next-line no-extra-semi
         ;(ws as any).removeAllListeners?.()
         ws.close()
-      }),
+      })
     ),
   )
 
@@ -72,7 +72,7 @@ const offer = (
             resume(Effect.fail(new WebSocketCloseError(e.code, e.reason)))
           })
         },
-      ),
+      )
     ),
   )
 
@@ -117,7 +117,7 @@ const send = (
     Effect.forever,
   )
 
-const make = Effect.gen(function* (_) {
+const make = Effect.gen(function*(_) {
   const log = yield* _(Log)
 
   const connect = (
@@ -126,7 +126,7 @@ const make = Effect.gen(function* (_) {
     onConnecting = Effect.unit,
     openTimeout = Duration.seconds(3),
   ) =>
-    Effect.gen(function* (_) {
+    Effect.gen(function*(_) {
       const queue = yield* _(Queue.unbounded<WebSocket.Data>())
 
       const run = onConnecting.pipe(
@@ -140,7 +140,7 @@ const make = Effect.gen(function* (_) {
               ),
             ],
             { concurrency: "unbounded", discard: true },
-          ),
+          )
         ),
         Effect.scoped,
         Effect.retryWhile(isReconnect),

package/src/DiscordGateway.ts

@@ -11,14 +11,13 @@ import type { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
 import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
 
-const fromDispatchFactory =
-  <R, E>(
-    source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
-  ) =>
-  <K extends keyof Discord.ReceiveEvents>(
-    event: K,
-  ): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
-    Stream.filter(source, p => p.t === event).pipe(Stream.map(p => p.d! as any))
+const fromDispatchFactory = <R, E>(
+  source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
+) =>
+<K extends keyof Discord.ReceiveEvents>(
+  event: K,
+): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
+  Stream.filter(source, p => p.t === event).pipe(Stream.map(p => p.d! as any))
 
 const handleDispatchFactory =
   (hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
@@ -58,7 +57,7 @@ export interface DiscordGateway {
 }
 export const DiscordGateway = Tag<DiscordGateway>()
 
-export const make = Effect.gen(function* (_) {
+export const make = Effect.gen(function*(_) {
   const sharder = yield* _(Sharder)
   const hub = yield* _(
     Hub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>(),

package/src/DiscordREST/types.ts

@@ -1,9 +1,9 @@
-import type * as Http from "@effect-http/client"
-import type { DiscordRESTError } from "dfx/DiscordREST"
 import type * as Effect from "@effect/io/Effect"
+import type * as Http from "@effect/platform/HttpClient"
+import type { DiscordRESTError } from "dfx/DiscordREST"
 
-export interface ResponseWithData<A> extends Http.response.Response {
-  readonly json: Effect.Effect<never, Http.ResponseDecodeError, A>
+export interface ResponseWithData<A> extends Http.response.ClientResponse {
+  readonly json: Effect.Effect<never, Http.error.ResponseError, A>
 }
 
 export type RestResponse<T> = Effect.Effect<

package/src/DiscordREST/utils.ts

@@ -1,5 +1,7 @@
-import * as Option from "@effect/data/Option"
 import * as Duration from "@effect/data/Duration"
+import * as HashMap from "@effect/data/HashMap"
+import * as Option from "@effect/data/Option"
+import type * as Http from "@effect/platform/HttpClient"
 
 const majorResources = ["channels", "guilds", "webhooks"] as const
 
@@ -7,8 +9,10 @@ export const routeFromConfig = (path: string, method: string) => {
   // Only keep major ID's
   const routeURL = path
     .split("?")[0]
-    .replace(/\/([A-Za-z]+)\/(\d{16,21}|@me)/g, (match, resource) =>
-      majorResources.includes(resource) ? match : `/${resource}`,
+    .replace(
+      /\/([A-Za-z]+)\/(\d{16,21}|@me)/g,
+      (match, resource) =>
+        majorResources.includes(resource) ? match : `/${resource}`,
     )
     // Strip reactions
     .replace(/\/reactions\/(.*)/, "/reactions")
@@ -16,21 +20,21 @@ export const routeFromConfig = (path: string, method: string) => {
   return `${method}-${routeURL}`
 }
 
-export const numberHeader = (headers: Headers) => (key: string) =>
-  Option.fromNullable(headers.get(key)).pipe(
+export const numberHeader = (headers: Http.headers.Headers) => (key: string) =>
+  HashMap.get(headers, key).pipe(
     Option.map(parseFloat),
     Option.filter(n => !isNaN(n)),
   )
 
-export const retryAfter = (headers: Headers) =>
+export const retryAfter = (headers: Http.headers.Headers) =>
   numberHeader(headers)("x-ratelimit-reset-after").pipe(
     Option.orElse(() => numberHeader(headers)("retry-after")),
     Option.map(Duration.seconds),
   )
 
-export const rateLimitFromHeaders = (headers: Headers) =>
+export const rateLimitFromHeaders = (headers: Http.headers.Headers) =>
   Option.all({
-    bucket: Option.fromNullable(headers.get("x-ratelimit-bucket")),
+    bucket: HashMap.get(headers, "x-ratelimit-bucket"),
     retryAfter: retryAfter(headers),
     limit: numberHeader(headers)("x-ratelimit-limit"),
     remaining: numberHeader(headers)("x-ratelimit-remaining"),