dfx 1.0.5 → 1.0.7

package/dist/src/Cache.ts

@@ -1,261 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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,
-    })
-  })