dfx 0.51.0 → 0.51.2

package/src/Cache/prelude.ts

@@ -1,34 +1,38 @@
+import * as Effect from "@effect/io/Effect"
+import * as Stream from "@effect/stream/Stream"
 import { DiscordREST } from "dfx"
-import { Discord, Effect, Stream } from "dfx/_common"
-import { DiscordGateway } from "dfx/gateway"
-import {
+import type {
   CacheDriver,
-  CacheMissError,
   CacheOp,
   ParentCacheDriver,
   ParentCacheOp,
-  make,
-  makeWithParent,
-} from "../Cache.js"
+} from "dfx/Cache"
+import { CacheMissError, make, makeWithParent } from "dfx/Cache"
+import { DiscordGateway } from "dfx/DiscordGateway"
+import type * as Discord from "dfx/types"
 
 export interface OptsWithParentOptions<E, A> {
-  id: (a: A) => string
-  fromParent: Stream<never, E, [parentId: string, resources: A[]]>
-  create: Stream<never, E, [parentId: string, resource: A]>
-  update: Stream<never, E, [parentId: string, resource: A]>
-  remove: Stream<never, E, [parentId: string, id: string]>
-  parentRemove: Stream<never, E, string>
+  readonly id: (a: A) => string
+  readonly fromParent: Stream.Stream<
+    never,
+    E,
+    [parentId: string, resources: Array<A>]
+  >
+  readonly create: Stream.Stream<never, E, [parentId: string, resource: A]>
+  readonly update: Stream.Stream<never, E, [parentId: string, resource: A]>
+  readonly remove: Stream.Stream<never, E, [parentId: string, id: string]>
+  readonly parentRemove: Stream.Stream<never, E, string>
 }
 
 export const opsWithParent = <E, T>({
-  id,
-  fromParent,
   create,
-  update,
-  remove,
+  fromParent,
+  id,
   parentRemove,
+  remove,
+  update,
 }: OptsWithParentOptions<E, T>) => {
-  const fromParentOps = fromParent.flatMap(([parentId, a]) =>
+  const fromParentOps = Stream.flatMap(fromParent, ([parentId, a]) =>
     Stream.fromIterable(
       a.map(
         (resource): ParentCacheOp<T> => ({
@@ -41,7 +45,8 @@ export const opsWithParent = <E, T>({
     ),
   )
 
-  const createOps = create.map(
+  const createOps = Stream.map(
+    create,
     ([parentId, resource]): ParentCacheOp<T> => ({
       op: "create",
       parentId,
@@ -50,7 +55,8 @@ export const opsWithParent = <E, T>({
     }),
   )
 
-  const updateOps = update.map(
+  const updateOps = Stream.map(
+    update,
     ([parentId, resource]): ParentCacheOp<T> => ({
       op: "update",
       parentId,
@@ -59,7 +65,8 @@ export const opsWithParent = <E, T>({
     }),
   )
 
-  const removeOps = remove.map(
+  const removeOps = Stream.map(
+    remove,
     ([parentId, resourceId]): ParentCacheOp<T> => ({
       op: "delete",
       parentId,
@@ -67,29 +74,31 @@ export const opsWithParent = <E, T>({
     }),
   )
 
-  const parentRemoveOps = parentRemove.map(
+  const parentRemoveOps = Stream.map(
+    parentRemove,
     (parentId): ParentCacheOp<T> => ({
       op: "parentDelete",
       parentId,
     }),
   )
 
-  return fromParentOps
-    .merge(createOps)
-    .merge(updateOps)
-    .merge(removeOps)
-    .merge(parentRemoveOps)
+  return Stream.merge(fromParentOps, createOps).pipe(
+    Stream.merge(updateOps),
+    Stream.merge(removeOps),
+    Stream.merge(parentRemoveOps),
+  )
 }
 
 export interface OpsOptions<E, A> {
   id: (a: A) => string
-  create: Stream<never, E, A>
-  update: Stream<never, E, A>
-  remove: Stream<never, E, string>
+  create: Stream.Stream<never, E, A>
+  update: Stream.Stream<never, E, A>
+  remove: Stream.Stream<never, E, string>
 }
 
-export const ops = <E, T>({ id, create, update, remove }: OpsOptions<E, T>) => {
-  const createOps = create.map(
+export const ops = <E, T>({ create, id, remove, update }: OpsOptions<E, T>) => {
+  const createOps = Stream.map(
+    create,
     (resource): CacheOp<T> => ({
       op: "create",
       resourceId: id(resource),
@@ -97,7 +106,8 @@ export const ops = <E, T>({ id, create, update, remove }: OpsOptions<E, T>) => {
     }),
   )
 
-  const updateOps = update.map(
+  const updateOps = Stream.map(
+    update,
     (resource): CacheOp<T> => ({
       op: "update",
       resourceId: id(resource),
@@ -105,30 +115,31 @@ export const ops = <E, T>({ id, create, update, remove }: OpsOptions<E, T>) => {
     }),
   )
 
-  const removeOps = remove.map(
+  const removeOps = Stream.map(
+    remove,
     (resourceId): CacheOp<T> => ({
       op: "delete",
       resourceId,
     }),
   )
 
-  return createOps.merge(updateOps).merge(removeOps)
+  return Stream.merge(createOps, updateOps).pipe(Stream.merge(removeOps))
 }
 
 export const guilds = <RM, EM, E>(
-  makeDriver: Effect<RM, EM, CacheDriver<E, Discord.Guild>>,
+  makeDriver: Effect.Effect<RM, EM, CacheDriver<E, Discord.Guild>>,
 ) =>
-  Do($ => {
-    const driver = $(makeDriver)
-    const gateway = $(DiscordGateway.accessWith(identity))
-    const rest = $(DiscordREST.accessWith(identity))
+  Effect.gen(function* (_) {
+    const driver = yield* _(makeDriver)
+    const gateway = yield* _(DiscordGateway)
+    const rest = yield* _(DiscordREST)
 
     return make({
       driver,
       id: _ => _.id,
       ops: ops({
         id: (g: Discord.Guild) => g.id,
-        create: gateway.fromDispatch("GUILD_CREATE").map(g => ({
+        create: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => ({
           ...g,
           channels: [],
           roles: [],
@@ -136,83 +147,94 @@ export const guilds = <RM, EM, E>(
           members: [],
         })),
         update: gateway.fromDispatch("GUILD_UPDATE"),
-        remove: gateway.fromDispatch("GUILD_DELETE").map(a => a.id),
+        remove: Stream.map(gateway.fromDispatch("GUILD_DELETE"), a => a.id),
       }),
-      onMiss: id => rest.getGuild(id).flatMap(r => r.json),
+      onMiss: id => Effect.flatMap(rest.getGuild(id), r => r.json),
     })
   })
 
 export const channels = <RM, EM, E>(
-  makeDriver: Effect<RM, EM, ParentCacheDriver<E, Discord.Channel>>,
+  makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Channel>>,
 ) =>
-  Do($ => {
-    const driver = $(makeDriver)
-    const gateway = $(DiscordGateway.accessWith(identity))
-    const rest = $(DiscordREST.accessWith(identity))
+  Effect.gen(function* (_) {
+    const driver = yield* _(makeDriver)
+    const gateway = yield* _(DiscordGateway)
+    const rest = yield* _(DiscordREST)
 
     return makeWithParent({
       driver,
       id: _ => Effect.succeed([_.guild_id!, _.id]),
       ops: opsWithParent({
         id: (a: Discord.Channel) => a.id,
-        fromParent: gateway
-          .fromDispatch("GUILD_CREATE")
-          .map(g => [g.id, g.channels.concat(g.threads)]),
-        create: gateway
-          .fromDispatch("CHANNEL_CREATE")
-          .merge(gateway.fromDispatch("THREAD_CREATE"))
-          .map(c => [c.guild_id!, c]),
-        update: gateway
-          .fromDispatch("CHANNEL_UPDATE")
-          .merge(gateway.fromDispatch("THREAD_UPDATE"))
-          .map(c => [c.guild_id!, c]),
-        remove: gateway
-          .fromDispatch("CHANNEL_DELETE")
-          .merge(gateway.fromDispatch("THREAD_DELETE"))
-          .map(a => [a.guild_id!, a.id]),
-        parentRemove: gateway.fromDispatch("GUILD_DELETE").map(g => g.id),
+        fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
+          g.id,
+          g.channels.concat(g.threads),
+        ]),
+        create: Stream.merge(
+          gateway.fromDispatch("CHANNEL_CREATE"),
+          gateway.fromDispatch("THREAD_CREATE"),
+        ).pipe(Stream.map(c => [c.guild_id!, c])),
+        update: Stream.merge(
+          gateway.fromDispatch("CHANNEL_UPDATE"),
+          gateway.fromDispatch("THREAD_UPDATE"),
+        ).pipe(Stream.map(c => [c.guild_id!, c])),
+        remove: Stream.merge(
+          gateway.fromDispatch("CHANNEL_DELETE"),
+          gateway.fromDispatch("THREAD_DELETE"),
+        ).pipe(Stream.map(a => [a.guild_id!, a.id])),
+        parentRemove: Stream.map(
+          gateway.fromDispatch("GUILD_DELETE"),
+          g => g.id,
+        ),
       }),
-      onMiss: (_, id) => rest.getChannel(id).flatMap(r => r.json),
+      onMiss: (_, id) => Effect.flatMap(rest.getChannel(id), r => r.json),
       onParentMiss: guildId =>
-        rest
-          .getGuildChannels(guildId)
-          .flatMap(r => r.json)
-          .map(a => a.map(a => [a.id, a])),
+        rest.getGuildChannels(guildId).pipe(
+          Effect.flatMap(r => r.json),
+          Effect.map(a => a.map(a => [a.id, a])),
+        ),
     })
   })
 
 export const roles = <RM, EM, E>(
-  makeDriver: Effect<RM, EM, ParentCacheDriver<E, Discord.Role>>,
+  makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Role>>,
 ) =>
-  Do($ => {
-    const driver = $(makeDriver)
-    const gateway = $(DiscordGateway.accessWith(identity))
-    const rest = $(DiscordREST.accessWith(identity))
+  Effect.gen(function* (_) {
+    const driver = yield* _(makeDriver)
+    const gateway = yield* _(DiscordGateway)
+    const rest = yield* _(DiscordREST)
 
     return makeWithParent({
       driver,
       id: _ => Effect.fail(new CacheMissError("RolesCache/id", _.id)),
       ops: opsWithParent({
         id: (a: Discord.Role) => a.id,
-        fromParent: gateway
-          .fromDispatch("GUILD_CREATE")
-          .map(g => [g.id, g.roles]),
-        create: gateway
-          .fromDispatch("GUILD_ROLE_CREATE")
-          .map(r => [r.guild_id, r.role]),
-        update: gateway
-          .fromDispatch("GUILD_ROLE_UPDATE")
-          .map(r => [r.guild_id, r.role]),
-        remove: gateway
-          .fromDispatch("GUILD_ROLE_DELETE")
-          .map(r => [r.guild_id, r.role_id]),
-        parentRemove: gateway.fromDispatch("GUILD_DELETE").map(g => g.id),
+        fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
+          g.id,
+          g.roles,
+        ]),
+        create: Stream.map(gateway.fromDispatch("GUILD_ROLE_CREATE"), r => [
+          r.guild_id,
+          r.role,
+        ]),
+        update: Stream.map(gateway.fromDispatch("GUILD_ROLE_UPDATE"), r => [
+          r.guild_id,
+          r.role,
+        ]),
+        remove: Stream.map(gateway.fromDispatch("GUILD_ROLE_DELETE"), r => [
+          r.guild_id,
+          r.role_id,
+        ]),
+        parentRemove: Stream.map(
+          gateway.fromDispatch("GUILD_DELETE"),
+          g => g.id,
+        ),
       }),
       onMiss: (_, id) => Effect.fail(new CacheMissError("RolesCache", id)),
       onParentMiss: guildId =>
-        rest
-          .getGuildRoles(guildId)
-          .flatMap(r => r.json)
-          .map(_ => _.map(role => [role.id, role])),
+        rest.getGuildRoles(guildId).pipe(
+          Effect.flatMap(r => r.json),
+          Effect.map(_ => _.map(role => [role.id, role])),
+        ),
     })
   })

package/src/Cache.ts

@@ -1,14 +1,17 @@
-import { CacheDriver, ParentCacheDriver } from "./Cache/driver.js"
+import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
+import * as Effect from "@effect/io/Effect"
+import * as Option from "@effect/data/Option"
+import * as Stream from "@effect/stream/Stream"
 
-export * from "./Cache/driver.js"
+export * from "dfx/Cache/driver"
 export {
   create as memoryDriver,
   createWithParent as memoryParentDriver,
-} from "./Cache/memory.js"
+} from "dfx/Cache/memory"
 export {
   create as memoryTTLDriver,
   createWithParent as memoryTTLParentDriver,
-} from "./Cache/memoryTTL.js"
+} from "dfx/Cache/memoryTTL"
 
 export type ParentCacheOp<T> =
   | { op: "create"; parentId: string; resourceId: string; resource: T }
@@ -23,53 +26,59 @@ export type CacheOp<T> =
 
 export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
   driver,
-  ops = Stream.empty,
   id,
   onMiss,
   onParentMiss,
+  ops = Stream.empty,
 }: {
   driver: ParentCacheDriver<EDriver, A>
-  ops?: Stream<never, EOps, ParentCacheOp<A>>
-  id: (_: A) => Effect<never, EMiss, readonly [parentId: string, id: string]>
-  onMiss: (parentId: string, id: string) => Effect<never, EMiss, A>
+  ops?: Stream.Stream<never, EOps, ParentCacheOp<A>>
+  id: (
+    _: A,
+  ) => Effect.Effect<never, EMiss, readonly [parentId: string, id: string]>
+  onMiss: (parentId: string, id: string) => Effect.Effect<never, EMiss, A>
   onParentMiss: (
     parentId: string,
-  ) => Effect<never, EPMiss, [id: string, resource: A][]>
+  ) => Effect.Effect<never, EPMiss, Array<[id: string, resource: A]>>
 }) => {
-  const sync = ops.tap((op): Effect<never, EDriver, void> => {
-    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)
-    }
-  }).runDrain
+  const sync = Stream.runDrain(
+    Stream.tap(ops, (op): Effect.Effect<never, EDriver, void> => {
+      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)
+      }
+    }),
+  )
 
   const get = (parentId: string, id: string) =>
-    driver.get(parentId, id).flatMap(_ =>
-      _.match({
+    Effect.flatMap(
+      driver.get(parentId, id),
+      Option.match({
         onNone: () =>
-          onMiss(parentId, id).tap(a => driver.set(parentId, id, a)),
+          Effect.tap(onMiss(parentId, id), a => driver.set(parentId, id, a)),
         onSome: Effect.succeed,
       }),
     )
 
   const put = (_: A) =>
-    id(_).flatMap(([parentId, id]) => driver.set(parentId, id, _))
+    Effect.flatMap(id(_), ([parentId, id]) => driver.set(parentId, id, _))
 
   const update = <R, E>(
     parentId: string,
     id: string,
-    f: (_: A) => Effect<R, E, A>,
+    f: (_: A) => Effect.Effect<R, E, A>,
   ) =>
-    get(parentId, id)
-      .flatMap(f)
-      .tap(_ => driver.set(parentId, id, _))
+    get(parentId, id).pipe(
+      Effect.flatMap(f),
+      Effect.tap(_ => driver.set(parentId, id, _)),
+    )
 
   return {
     ...driver,
@@ -79,68 +88,74 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
     update,
 
     getForParent: (parentId: string) =>
-      driver.getForParent(parentId).flatMap(_ =>
-        _.match({
+      Effect.flatMap(
+        driver.getForParent(parentId),
+        Option.match({
           onNone: () =>
-            onParentMiss(parentId)
-              .tap(entries =>
+            onParentMiss(parentId).pipe(
+              Effect.tap(entries =>
                 Effect.all(
                   entries.map(([id, a]) => driver.set(parentId, id, a)),
                   { concurrency: "unbounded" },
                 ),
-              )
-              .map(entries => new Map(entries) as ReadonlyMap<string, A>),
+              ),
+              Effect.map(entries => new Map(entries) as ReadonlyMap<string, A>),
+            ),
           onSome: Effect.succeed,
         }),
       ),
 
-    run: sync.zipRight(driver.run, { parallel: true }),
+    run: Effect.zipRight(sync, driver.run, { parallel: true }),
   }
 }
 
 export const make = <EOps, EDriver, EMiss, A>({
   driver,
-  ops = Stream.empty,
   id,
   onMiss,
+  ops = Stream.empty,
 }: {
   driver: CacheDriver<EDriver, A>
-  ops?: Stream<never, EOps, CacheOp<A>>
+  ops?: Stream.Stream<never, EOps, CacheOp<A>>
   id: (_: A) => string
-  onMiss: (id: string) => Effect<never, EMiss, A>
+  onMiss: (id: string) => Effect.Effect<never, EMiss, A>
 }) => {
-  const sync = ops.tap((op): Effect<never, EDriver, void> => {
-    switch (op.op) {
-      case "create":
-      case "update":
-        return driver.set(op.resourceId, op.resource)
-
-      case "delete":
-        return driver.delete(op.resourceId)
-    }
-  }).runDrain
+  const sync = Stream.runDrain(
+    Stream.tap(ops, (op): Effect.Effect<never, EDriver, void> => {
+      switch (op.op) {
+        case "create":
+        case "update":
+          return driver.set(op.resourceId, op.resource)
+
+        case "delete":
+          return driver.delete(op.resourceId)
+      }
+    }),
+  )
 
   const get = (id: string) =>
-    driver.get(id).flatMap(_ =>
-      _.match({
-        onNone: () => onMiss(id).tap(a => driver.set(id, a)),
+    Effect.flatMap(
+      driver.get(id),
+      Option.match({
+        onNone: () => Effect.tap(onMiss(id), a => driver.set(id, a)),
         onSome: Effect.succeed,
       }),
     )
 
   const put = (_: A) => driver.set(id(_), _)
 
-  const update = <R, E>(id: string, f: (_: A) => Effect<R, E, A>) =>
-    get(id)
-      .flatMap(f)
-      .tap(_ => driver.set(id, _))
+  const update = <R, E>(id: string, f: (_: A) => Effect.Effect<R, E, A>) =>
+    get(id).pipe(
+      Effect.flatMap(f),
+      Effect.tap(_ => driver.set(id, _)),
+    )
 
   return {
     ...driver,
     get,
     put,
     update,
-    run: sync.zipRight(driver.run, { parallel: true }),
+    run: Effect.zipRight(sync, driver.run, { parallel: true }),
   }
 }
 

package/src/DiscordConfig.ts

@@ -1,30 +1,39 @@
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import * as Config from "@effect/io/Config"
+import * as ConfigError from "@effect/io/Config/Error"
+import * as ConfigSecret from "@effect/io/Config/Secret"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as Discord from "dfx/types"
+
 const VERSION = 10
 
 export interface DiscordConfig {
-  token: ConfigSecret
-  debug: boolean
-  rest: {
-    baseUrl: string
-    globalRateLimit: {
-      limit: number
-      window: Duration
+  readonly token: ConfigSecret.ConfigSecret
+  readonly debug: boolean
+  readonly rest: {
+    readonly baseUrl: string
+    readonly globalRateLimit: {
+      readonly limit: number
+      readonly window: Duration.DurationInput
     }
   }
-  gateway: {
-    intents: number
-    presence?: Discord.UpdatePresence
-    shardCount?: number
+  readonly gateway: {
+    readonly intents: number
+    readonly presence?: Discord.UpdatePresence
+    readonly shardCount?: number
 
-    identifyRateLimit: readonly [window: number, limit: number]
+    readonly identifyRateLimit: readonly [window: number, limit: number]
   }
 }
 export const DiscordConfig = Tag<DiscordConfig>()
 
 export interface MakeOpts {
-  token: ConfigSecret
-  debug?: boolean
-  rest?: Partial<DiscordConfig["rest"]>
-  gateway?: Partial<DiscordConfig["gateway"]>
+  readonly token: ConfigSecret.ConfigSecret
+  readonly debug?: boolean
+  readonly rest?: Partial<DiscordConfig["rest"]>
+  readonly gateway?: Partial<DiscordConfig["gateway"]>
 }
 
 export const make = ({
@@ -51,7 +60,12 @@ export const make = ({
   },
 })
 
-export const makeLayer = (opts: MakeOpts) =>
+export const makeLayer = (
+  opts: MakeOpts,
+): Layer.Layer<never, never, DiscordConfig> =>
   Layer.succeed(DiscordConfig, make(opts))
-export const makeFromConfig = (_: Config.Wrap<MakeOpts>) =>
-  Layer.effect(DiscordConfig, Config.unwrap(_).config.map(make))
+
+export const makeFromConfig = (
+  _: Config.Config.Wrap<MakeOpts>,
+): Layer.Layer<never, ConfigError.ConfigError, DiscordConfig> =>
+  Layer.effect(DiscordConfig, Effect.map(Effect.config(Config.unwrap(_)), make))