dfx 1.0.3 → 1.0.5

package/dist/src/Cache.ts

@@ -0,0 +1,261 @@
+import type { CacheDriver, ParentCacheDriver } from "./Cache/driver.ts"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Schedule from "effect/Schedule"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+
+export * from "./Cache/driver.ts"
+export {
+  create as memoryDriver,
+  createWithParent as memoryParentDriver,
+} from "./Cache/memory.ts"
+export {
+  create as memoryTTLDriver,
+  createWithParent as memoryTTLParentDriver,
+} from "./Cache/memoryTTL.ts"
+
+export type ParentCacheOp<T> =
+  | { op: "create"; parentId: string; resourceId: string; resource: T }
+  | { op: "update"; parentId: string; resourceId: string; resource: T }
+  | { op: "delete"; parentId: string; resourceId: string }
+  | { op: "parentDelete"; parentId: string }
+
+export type CacheOp<T> =
+  | { op: "create"; resourceId: string; resource: T }
+  | { op: "update"; resourceId: string; resource: T }
+  | { op: "delete"; resourceId: string }
+
+const retryPolicy = Schedule.exponential("500 millis").pipe(
+  Schedule.either(Schedule.spaced("10 seconds")),
+)
+
+export interface ParentCache<EDriver, EMiss, EPMiss, A> {
+  readonly get: (
+    parentId: string,
+    id: string,
+  ) => Effect.Effect<A, EDriver | EMiss>
+  readonly put: (_: A) => Effect.Effect<void, EDriver | EMiss>
+  readonly update: <R, E>(
+    parentId: string,
+    id: string,
+    f: (_: A) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, EDriver | EMiss | E, R>
+  readonly getForParent: (
+    parentId: string,
+  ) => Effect.Effect<ReadonlyMap<string, A>, EDriver | EPMiss>
+  readonly size: Effect.Effect<number, EDriver>
+  readonly sizeForParent: (parentId: string) => Effect.Effect<number, EDriver>
+  readonly set: (
+    parentId: string,
+    resourceId: string,
+    resource: A,
+  ) => Effect.Effect<void, EDriver>
+  readonly delete: (
+    parentId: string,
+    resourceId: string,
+  ) => Effect.Effect<void, EDriver>
+  readonly parentDelete: (parentId: string) => Effect.Effect<void, EDriver>
+  readonly refreshTTL: (
+    parentId: string,
+    resourceId: string,
+  ) => Effect.Effect<void, EDriver>
+}
+
+export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
+  driver,
+  id: identify,
+  onMiss,
+  onParentMiss,
+  ops = Stream.empty,
+}: {
+  driver: ParentCacheDriver<EDriver, A>
+  ops?: Stream.Stream<ParentCacheOp<A>, EOps>
+  id: (_: A) => Effect.Effect<readonly [parentId: string, id: string], EMiss>
+  onMiss: (parentId: string, id: string) => Effect.Effect<A, EMiss>
+  onParentMiss: (
+    parentId: string,
+  ) => Effect.Effect<Array<readonly [id: string, resource: A]>, EPMiss>
+}): Effect.Effect<ParentCache<EDriver, EMiss, EPMiss, A>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    yield* Stream.runDrain(
+      Stream.tap(ops, (op): Effect.Effect<void, EDriver> => {
+        switch (op.op) {
+          case "create":
+          case "update":
+            return driver.set(op.parentId, op.resourceId, op.resource)
+
+          case "delete":
+            return driver.delete(op.parentId, op.resourceId)
+
+          case "parentDelete":
+            return driver.parentDelete(op.parentId)
+        }
+      }),
+    ).pipe(
+      Effect.tapCause(cause => Effect.logError("ops error, restarting", cause)),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
+      Effect.interruptible,
+    )
+    yield* driver.run.pipe(
+      Effect.tapCause(cause =>
+        Effect.logError("cache driver error, restarting", cause),
+      ),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
+      Effect.interruptible,
+    )
+
+    const get = (parentId: string, id: string) =>
+      Effect.flatMap(driver.get(parentId, id), option =>
+        Option.match(option, {
+          onNone: () =>
+            Effect.tap(onMiss(parentId, id), a => driver.set(parentId, id, a)),
+          onSome: Effect.succeed,
+        }),
+      )
+
+    const put = (_: A) =>
+      Effect.flatMap(identify(_), ([parentId, id]) =>
+        driver.set(parentId, id, _),
+      )
+
+    const update = <R, E>(
+      parentId: string,
+      id: string,
+      f: (_: A) => Effect.Effect<A, E, R>,
+    ) =>
+      Effect.flatMap(get(parentId, id), a =>
+        Effect.tap(f(a), next => driver.set(parentId, id, next)),
+      )
+
+    return {
+      ...driver,
+
+      get,
+      put,
+      update,
+
+      getForParent: (parentId: string) =>
+        Effect.flatMap(driver.getForParent(parentId), option =>
+          Option.match(option, {
+            onNone: () =>
+              onParentMiss(parentId).pipe(
+                Effect.tap(entries =>
+                  Effect.all(
+                    entries.map(([id, a]) => driver.set(parentId, id, a)),
+                    { concurrency: "unbounded" },
+                  ),
+                ),
+                Effect.map(
+                  entries => new Map(entries) as ReadonlyMap<string, A>,
+                ),
+              ),
+            onSome: Effect.succeed,
+          }),
+        ),
+    } as const
+  }).pipe(
+    Effect.annotateLogs({
+      package: "dfx",
+      service: "Cache",
+    }),
+  )
+
+export interface Cache<EDriver, EMiss, A> {
+  readonly get: (id: string) => Effect.Effect<A, EDriver | EMiss>
+  readonly put: (_: A) => Effect.Effect<void, EDriver>
+  readonly update: <R, E>(
+    id: string,
+    f: (_: A) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, EDriver | EMiss | E, R>
+  readonly size: Effect.Effect<number, EDriver>
+  readonly set: (
+    resourceId: string,
+    resource: A,
+  ) => Effect.Effect<void, EDriver>
+  readonly delete: (resourceId: string) => Effect.Effect<void, EDriver>
+  readonly refreshTTL: (resourceId: string) => Effect.Effect<void, EDriver>
+}
+
+export const make = <EOps, EDriver, EMiss, A>({
+  driver,
+  id: identify,
+  onMiss,
+  ops = Stream.empty,
+}: {
+  driver: CacheDriver<EDriver, A>
+  ops?: Stream.Stream<CacheOp<A>, EOps>
+  id: (_: A) => string
+  onMiss: (id: string) => Effect.Effect<A, EMiss>
+}): Effect.Effect<Cache<EDriver, EMiss, A>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    yield* Stream.runDrain(
+      Stream.tap(ops, (op): Effect.Effect<void, EDriver> => {
+        switch (op.op) {
+          case "create":
+          case "update":
+            return driver.set(op.resourceId, op.resource)
+
+          case "delete":
+            return driver.delete(op.resourceId)
+        }
+      }),
+    ).pipe(
+      Effect.tapCause(cause => Effect.logError("ops error, restarting", cause)),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
+      Effect.interruptible,
+    )
+
+    yield* driver.run.pipe(
+      Effect.tapCause(cause =>
+        Effect.logError("cache driver error, restarting", cause),
+      ),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
+      Effect.interruptible,
+    )
+
+    const get = (id: string) =>
+      Effect.flatMap(driver.get(id), option =>
+        Option.match(option, {
+          onNone: () => Effect.tap(onMiss(id), a => driver.set(id, a)),
+          onSome: Effect.succeed,
+        }),
+      )
+
+    const put = (_: A) => driver.set(identify(_), _)
+
+    const update = <R, E>(id: string, f: (_: A) => Effect.Effect<A, E, R>) =>
+      Effect.flatMap(get(id), a =>
+        Effect.tap(f(a), next => driver.set(id, next)),
+      )
+
+    return {
+      ...driver,
+      get,
+      put,
+      update,
+    } as const
+  }).pipe(
+    Effect.annotateLogs({
+      package: "dfx",
+      service: "Cache",
+    }),
+  )
+
+export const CacheErrorTypeId = Symbol.for("dfx/Cache/CacheError")
+
+export class CacheMissError extends Data.Error<{
+  cacheName: string
+  id: string
+}> {
+  readonly _tag = "CacheMissError"
+
+  get message() {
+    return `Cache miss for "${this.cacheName}" with id: ${this.id}`
+  }
+}

package/dist/src/DiscordConfig.ts

@@ -0,0 +1,67 @@
+import * as Discord from "./types.ts"
+import * as Config from "effect/Config"
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type * as Redacted from "effect/Redacted"
+import * as ServiceMap from "effect/ServiceMap"
+
+const VERSION = 10
+
+export interface DiscordConfigService {
+  readonly token: Redacted.Redacted
+  readonly rest: {
+    readonly baseUrl: string
+    readonly globalRateLimit: {
+      readonly limit: number
+      readonly window: Duration.Input
+    }
+  }
+  readonly gateway: {
+    readonly intents: number
+    readonly presence?: Discord.GatewayPresenceUpdateData
+    readonly shardCount?: number
+
+    readonly identifyRateLimit: readonly [window: number, limit: number]
+  }
+}
+export class DiscordConfig extends ServiceMap.Service<
+  DiscordConfig,
+  DiscordConfigService
+>()("dfx/DiscordConfig") {}
+
+export interface MakeOpts {
+  readonly token: Redacted.Redacted
+  readonly rest?: Partial<DiscordConfigService["rest"]>
+  readonly gateway?: Partial<DiscordConfigService["gateway"]>
+}
+
+export const make = ({
+  gateway,
+  rest,
+  token,
+}: MakeOpts): DiscordConfigService => ({
+  token,
+  rest: {
+    baseUrl: `https://discord.com/api/v${VERSION}`,
+    ...rest,
+    globalRateLimit: {
+      limit: 50,
+      window: Duration.seconds(1),
+      ...rest?.globalRateLimit,
+    },
+  },
+  gateway: {
+    intents: Discord.GatewayIntentBits.Guilds,
+    identifyRateLimit: [5000, 1],
+    ...gateway,
+  },
+})
+
+export const layer = (opts: MakeOpts): Layer.Layer<DiscordConfig> =>
+  Layer.succeed(DiscordConfig, make(opts))
+
+export const layerConfig = (
+  _: Config.Wrap<MakeOpts>,
+): Layer.Layer<DiscordConfig, Config.ConfigError> =>
+  Layer.effect(DiscordConfig, Effect.map(Config.unwrap(_).asEffect(), make))

package/dist/src/DiscordGateway/DiscordWS.ts

@@ -0,0 +1,157 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import type * as Discord from "../types.ts"
+import * as Schedule from "effect/Schedule"
+import * as Cause from "effect/Cause"
+import * as ServiceMap from "effect/ServiceMap"
+import * as Queue from "effect/Queue"
+import * as Socket from "effect/unstable/socket/Socket"
+import type * as Scope from "effect/Scope"
+import { CurrentLoggers } from "effect/Logger"
+import * as LogLevel from "effect/LogLevel"
+import { MinimumLogLevel } from "effect/References"
+
+export type Message = Discord.GatewayReceivePayload
+export type MessageSend = Discord.GatewaySendPayload | Reconnect
+
+export const Reconnect = Symbol.for("dfx/DiscordGateway/WS/Reconnect")
+export type Reconnect = typeof Reconnect
+
+export interface OpenOpts {
+  url?: string
+  version?: number
+  encoding?: DiscordWSCodec
+  onConnecting: Effect.Effect<void>
+}
+
+export interface DiscordWSCodecService {
+  type: "json" | "etf"
+  encode: (p: Discord.GatewaySendPayload) => Uint8Array | string
+  decode: (p: Uint8Array | string) => Discord.GatewayReceivePayload
+}
+
+const decoder = new TextDecoder()
+
+export class DiscordWSCodec extends ServiceMap.Service<
+  DiscordWSCodec,
+  DiscordWSCodecService
+>()("dfx/DiscordGateway/DiscordWS/Codec") {}
+
+export const JsonDiscordWSCodecLive = Layer.succeed(DiscordWSCodec, {
+  type: "json",
+  encode: p => JSON.stringify(p),
+  decode: p => JSON.parse(typeof p === "string" ? p : decoder.decode(p)),
+})
+
+const make = Effect.gen(function* () {
+  const encoding = yield* DiscordWSCodec
+
+  const connect = Effect.fnUntraced(
+    function* ({
+      onConnecting,
+      url = "wss://gateway.discord.gg/",
+      version = 10,
+    }: OpenOpts) {
+      const urlRef = yield* Ref.make(
+        `${url}?v=${version}&encoding=${encoding.type}`,
+      )
+      const setUrl = (nextUrl: string) =>
+        Ref.set(urlRef, `${nextUrl}?v=${version}&encoding=${encoding.type}`)
+      const messages = yield* Queue.make<Message>()
+      const socket = yield* Socket.makeWebSocket(Ref.get(urlRef), {
+        closeCodeIsError: _ => true,
+        openTimeout: 5000,
+      })
+      const writeRaw = yield* socket.writer
+      const logWriteError = (cause: Cause.Cause<Socket.SocketError>) =>
+        Effect.annotateLogs(Effect.logDebug(cause), {
+          module: "DiscordGateway/DiscordWS",
+          channel: "outbound",
+        })
+      const write = (message: MessageSend): Effect.Effect<void> => {
+        if (message === Reconnect) {
+          return Effect.catchCause(
+            writeRaw(new Socket.CloseEvent(3000, "reconnecting")),
+            logWriteError,
+          )
+        }
+        return Effect.catchCause(
+          writeRaw(encoding.encode(message)),
+          logWriteError,
+        )
+      }
+      const traceEnabled = LogLevel.isLessThanOrEqualTo(
+        yield* MinimumLogLevel,
+        "Trace",
+      )
+      const loggers = yield* CurrentLoggers
+      yield* onConnecting.pipe(
+        Effect.andThen(
+          Effect.withFiber<void, Socket.SocketError>(fiber =>
+            socket.runRaw(_ => {
+              const message = encoding.decode(_)
+              Queue.offerUnsafe(messages, message)
+              if (!traceEnabled) return
+              loggers.forEach(logger => {
+                logger.log({
+                  message,
+                  cause: Cause.empty,
+                  fiber,
+                  logLevel: "Trace",
+                  date: new Date(),
+                })
+              })
+            }),
+          ),
+        ),
+        Effect.retry({
+          while: e =>
+            e.reason._tag === "SocketCloseError" && e.reason.code === 3000,
+        }),
+        Effect.catchCause(cause =>
+          Effect.logDebug("Got socket error, reconnecting", cause),
+        ),
+        Effect.repeat(
+          Schedule.exponential(500).pipe(
+            Schedule.either(Schedule.spaced(10000)),
+          ),
+        ),
+        Effect.annotateLogs("channel", "inbound"),
+        Effect.forkScoped,
+      )
+
+      return {
+        take: Queue.take(messages),
+        setUrl,
+        write,
+      } as const
+    },
+    Effect.annotateLogs({
+      module: "DiscordGateway/DiscordWS",
+    }),
+  )
+
+  return { connect } as const
+})
+
+export class DiscordWS extends ServiceMap.Service<
+  DiscordWS,
+  {
+    readonly connect: (args_0: OpenOpts) => Effect.Effect<
+      {
+        readonly take: Effect.Effect<
+          Discord.GatewayReceivePayload,
+          never,
+          never
+        >
+        readonly setUrl: (url: string) => Effect.Effect<void, never, never>
+        readonly write: (message: MessageSend) => Effect.Effect<void>
+      },
+      never,
+      Socket.WebSocketConstructor | Scope.Scope
+    >
+  }
+>()("dfx/DiscordGateway/DiscordWS") {}
+
+export const DiscordWSLive = Layer.effect(DiscordWS, make)

package/dist/src/DiscordGateway/Messaging.ts

@@ -0,0 +1,71 @@
+import * as Effect from "effect/Effect"
+import * as PubSub from "effect/PubSub"
+import * as Layer from "effect/Layer"
+import * as Stream from "effect/Stream"
+import type * as Discord from "../types.ts"
+import * as EffectUtils from "../utils/Effect.ts"
+import * as Queue from "effect/Queue"
+import * as ServiceMap from "effect/ServiceMap"
+
+const fromDispatchFactory =
+  <R, E>(source: Stream.Stream<Discord.GatewayReceivePayload, E, R>) =>
+  <K extends `${Discord.GatewayDispatchEvents}`>(
+    event: K,
+  ): Stream.Stream<
+    Extract<Discord.DistributedGatewayDispatchPayload, { readonly t: K }>["d"],
+    E,
+    R
+  > =>
+    Stream.map(
+      Stream.filter(source, p => p.t === event),
+      p => p.d,
+    ) as any
+
+const handleDispatchFactory =
+  (hub: PubSub.PubSub<Discord.GatewayReceivePayload>) =>
+  <K extends `${Discord.GatewayDispatchEvents}`, R, E, A>(
+    event: K,
+    handle: (
+      event: Extract<Discord.GatewayDispatchPayload, { readonly t: K }>["d"],
+    ) => Effect.Effect<A, E, R>,
+  ): Effect.Effect<never, E, R> =>
+    EffectUtils.subscribeForEachPar(hub, _ => {
+      if (_.t === event) {
+        return handle(_.d as any)
+      }
+      return Effect.void as any
+    })
+
+export const make = Effect.gen(function* () {
+  const hub = yield* Effect.acquireRelease(
+    PubSub.unbounded<Discord.GatewayReceivePayload>(),
+    PubSub.shutdown,
+  )
+
+  const sendMailbox = yield* Effect.acquireRelease(
+    Queue.make<Discord.GatewaySendPayload>(),
+    Queue.shutdown,
+  )
+  const send = (payload: Discord.GatewaySendPayload) =>
+    Queue.offer(sendMailbox, payload)
+
+  const dispatch = Stream.fromPubSub(hub)
+  const fromDispatch = fromDispatchFactory(dispatch)
+  const handleDispatch = handleDispatchFactory(hub)
+
+  return {
+    hub,
+    sendMailbox,
+    dispatch,
+    fromDispatch,
+    handleDispatch,
+    send,
+  } as const
+})
+
+export class Messaging extends ServiceMap.Service<Messaging>()(
+  "dfx/DiscordGateway/Messaging",
+  { make },
+) {}
+export type Messsaging = Messaging
+export const MesssagingLive = Layer.effect(Messaging, make)

package/dist/src/DiscordGateway/Shard/StateStore.ts

@@ -0,0 +1,72 @@
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Layer from "effect/Layer"
+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
+  readonly sequence: number | null
+  readonly sessionId: string
+}
+
+export interface StateStore {
+  readonly get: Effect.Effect<Option.Option<ShardState>>
+  readonly set: (state: ShardState) => Effect.Effect<void>
+  readonly clear: Effect.Effect<void>
+}
+
+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,
+    () => {
+      const store = new Map<string, ShardState>()
+
+      return ShardStateStore.of({
+        forShard: ([id, count]) => {
+          const key = `${id}-${count}`
+          return {
+            get: Effect.sync(() => Option.fromUndefinedOr(store.get(key))),
+            set(state) {
+              return Effect.sync(() => {
+                store.set(key, state)
+              })
+            },
+            clear: Effect.sync(() => {
+              store.delete(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/dist/src/DiscordGateway/Shard/heartbeats.ts

@@ -0,0 +1,60 @@
+import * as Option from "effect/Option"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
+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, shardState =>
+    SendEvents.heartbeat(
+      Option.getOrNull(Option.map(shardState, s => s.sequence)),
+    ),
+  )
+
+const payloadOrReconnect = (
+  ref: Ref.Ref<boolean>,
+  state: Effect.Effect<Option.Option<ShardState>>,
+) =>
+  Effect.flatMap(
+    Ref.get(ref),
+    (acked): Effect.Effect<DiscordWS.MessageSend> =>
+      acked ? payload(state) : Effect.succeed(DiscordWS.Reconnect),
+  )
+
+export const send = (
+  hellos: Queue.Dequeue<Discord.GatewayHelloData>,
+  acks: Queue.Dequeue<void>,
+  state: Effect.Effect<Option.Option<ShardState>>,
+  sendMessage: (p: DiscordWS.MessageSend) => Effect.Effect<void>,
+) =>
+  Effect.flatMap(Ref.make(true), ackedRef => {
+    const sendPayload = payloadOrReconnect(ackedRef, state).pipe(
+      Effect.tap(Ref.set(ackedRef, false)),
+      Effect.flatMap(sendMessage),
+    )
+
+    const heartbeats = EffectU.foreverSwitch(
+      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 = Queue.take(acks).pipe(
+      Effect.tap(Ref.set(ackedRef, true)),
+      Effect.forever,
+    )
+
+    return Effect.all([run, heartbeats], {
+      concurrency: "unbounded",
+      discard: true,
+    })
+  })