dfx 0.74.0 → 0.76.0

package/src/Cache.ts

@@ -1,4 +1,6 @@
 import * as Option from "effect/Option"
+import * as Schedule from "effect/Schedule"
+import type * as Scope from "effect/Scope"
 import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
 import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
@@ -24,7 +26,11 @@ export type CacheOp<T> =
   | { op: "update"; resourceId: string; resource: T }
   | { op: "delete"; resourceId: string }
 
-export interface ParentCache<EOps, EDriver, EMiss, EPMiss, A> {
+const retryPolicy = Schedule.exponential("500 millis").pipe(
+  Schedule.union(Schedule.spaced("10 seconds")),
+)
+
+export interface ParentCache<EDriver, EMiss, EPMiss, A> {
   readonly get: (
     parentId: string,
     id: string,
@@ -38,7 +44,6 @@ export interface ParentCache<EOps, EDriver, EMiss, EPMiss, A> {
   readonly getForParent: (
     parentId: string,
   ) => Effect.Effect<never, EDriver | EPMiss, ReadonlyMap<string, A>>
-  readonly run: Effect.Effect<never, EOps | EDriver, void>
   readonly size: Effect.Effect<never, EDriver, number>
   readonly sizeForParent: (
     parentId: string,
@@ -77,86 +82,101 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
   onParentMiss: (
     parentId: string,
   ) => Effect.Effect<never, EPMiss, Array<[id: string, resource: A]>>
-}): ParentCache<EOps, EDriver, EMiss, EPMiss, A> => {
-  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)
-      }
-    }),
-  )
+}): Effect.Effect<Scope.Scope, never, ParentCache<EDriver, EMiss, EPMiss, A>> =>
+  Effect.gen(function* (_) {
+    yield* _(
+      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)
 
-  const get = (parentId: string, id: string) =>
-    Effect.flatMap(
-      driver.get(parentId, id),
-      Option.match({
-        onNone: () =>
-          Effect.tap(onMiss(parentId, id), a => driver.set(parentId, id, a)),
-        onSome: Effect.succeed,
-      }),
-    )
-
-  const put = (_: A) =>
-    Effect.flatMap(id(_), ([parentId, id]) => driver.set(parentId, id, _))
+            case "delete":
+              return driver.delete(op.parentId, op.resourceId)
 
-  const update = <R, E>(
-    parentId: string,
-    id: string,
-    f: (_: A) => Effect.Effect<R, E, A>,
-  ) =>
-    get(parentId, id).pipe(
-      Effect.flatMap(f),
-      Effect.tap(_ => driver.set(parentId, id, _)),
+            case "parentDelete":
+              return driver.parentDelete(op.parentId)
+          }
+        }),
+      ),
+      Effect.tapErrorCause(_ => Effect.logError("ops error, restarting", _)),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
+    )
+    yield* _(
+      driver.run,
+      Effect.tapErrorCause(_ =>
+        Effect.logError("cache driver error, restarting", _),
+      ),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
     )
 
-  return {
-    ...driver,
-
-    get,
-    put,
-    update,
-
-    getForParent: (parentId: string) =>
+    const get = (parentId: string, id: string) =>
       Effect.flatMap(
-        driver.getForParent(parentId),
+        driver.get(parentId, id),
         Option.match({
           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>),
-            ),
+            Effect.tap(onMiss(parentId, id), a => driver.set(parentId, id, a)),
           onSome: Effect.succeed,
         }),
-      ),
+      )
+
+    const put = (_: A) =>
+      Effect.flatMap(id(_), ([parentId, id]) => driver.set(parentId, id, _))
+
+    const update = <R, E>(
+      parentId: string,
+      id: string,
+      f: (_: A) => Effect.Effect<R, E, A>,
+    ) =>
+      get(parentId, id).pipe(
+        Effect.flatMap(f),
+        Effect.tap(_ => driver.set(parentId, id, _)),
+      )
+
+    return {
+      ...driver,
+
+      get,
+      put,
+      update,
 
-    run: Effect.all([sync, driver.run], {
-      concurrency: "unbounded",
-      discard: true,
+      getForParent: (parentId: string) =>
+        Effect.flatMap(
+          driver.getForParent(parentId),
+          Option.match({
+            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",
     }),
-  } as const
-}
+  )
 
-export interface Cache<EOps, EDriver, EMiss, A> {
+export interface Cache<EDriver, EMiss, A> {
   readonly get: (id: string) => Effect.Effect<never, EDriver | EMiss, A>
   readonly put: (_: A) => Effect.Effect<never, EDriver, void>
   readonly update: <R, E>(
     id: string,
     f: (_: A) => Effect.Effect<R, E, A>,
   ) => Effect.Effect<R, EDriver | EMiss | E, A>
-  readonly run: Effect.Effect<never, EOps | EDriver, void>
   readonly size: Effect.Effect<never, EDriver, number>
   readonly set: (
     resourceId: string,
@@ -178,48 +198,64 @@ export const make = <EOps, EDriver, EMiss, A>({
   ops?: Stream.Stream<never, EOps, CacheOp<A>>
   id: (_: A) => string
   onMiss: (id: string) => Effect.Effect<never, EMiss, A>
-}): Cache<EOps, EDriver, EMiss, A> => {
-  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)
-      }
-    }),
-  )
+}): Effect.Effect<Scope.Scope, never, Cache<EDriver, EMiss, A>> =>
+  Effect.gen(function* (_) {
+    yield* _(
+      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)
 
-  const get = (id: string) =>
-    Effect.flatMap(
-      driver.get(id),
-      Option.match({
-        onNone: () => Effect.tap(onMiss(id), a => driver.set(id, a)),
-        onSome: Effect.succeed,
-      }),
+            case "delete":
+              return driver.delete(op.resourceId)
+          }
+        }),
+      ),
+      Effect.tapErrorCause(_ => Effect.logError("ops error, restarting", _)),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
     )
 
-  const put = (_: A) => 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, _)),
+    yield* _(
+      driver.run,
+      Effect.tapErrorCause(_ =>
+        Effect.logError("cache driver error, restarting", _),
+      ),
+      Effect.retry(retryPolicy),
+      Effect.forkScoped,
     )
 
-  return {
-    ...driver,
-    get,
-    put,
-    update,
-    run: Effect.all([sync, driver.run], {
-      concurrency: "unbounded",
-      discard: true,
+    const get = (id: string) =>
+      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.Effect<R, E, A>) =>
+      get(id).pipe(
+        Effect.flatMap(f),
+        Effect.tap(_ => driver.set(id, _)),
+      )
+
+    return {
+      ...driver,
+      get,
+      put,
+      update,
+    } as const
+  }).pipe(
+    Effect.annotateLogs({
+      package: "dfx",
+      service: "Cache",
     }),
-  } as const
-}
+  )
 
 export class CacheMissError {
   readonly _tag = "CacheMissError"

package/src/DiscordGateway/DiscordWS.ts

@@ -70,6 +70,6 @@ const make = Effect.gen(function* (_) {
 export interface DiscordWS extends Effect.Effect.Success<typeof make> {}
 export const DiscordWS = Tag<DiscordWS>()
 export const LiveDiscordWS = Layer.provide(
-  LiveWS,
   Layer.effect(DiscordWS, make),
+  LiveWS,
 )

package/src/DiscordGateway/Shard.ts

@@ -192,8 +192,8 @@ export const make = Effect.gen(function* (_) {
 export interface Shard extends Effect.Effect.Success<typeof make> {}
 export const Shard = Tag<Shard>()
 export const LiveShard = Layer.provide(
-  Layer.merge(LiveDiscordWS, LiveRateLimiter),
   Layer.effect(Shard, make),
+  Layer.merge(LiveDiscordWS, LiveRateLimiter),
 )
 
 export interface RunningShard

package/src/DiscordGateway/Sharder.ts

@@ -135,6 +135,6 @@ const make = Effect.gen(function* (_) {
 export interface Sharder extends Effect.Effect.Success<typeof make> {}
 export const Sharder = Tag<Sharder>()
 export const LiveSharder = Layer.provide(
-  Layer.merge(LiveRateLimiter, LiveShard),
   Layer.effect(Sharder, make),
+  Layer.merge(LiveRateLimiter, LiveShard),
 )

package/src/DiscordGateway.ts

@@ -7,9 +7,9 @@ import * as Queue from "effect/Queue"
 import * as Stream from "effect/Stream"
 import type { RunningShard } from "dfx/DiscordGateway/Shard"
 import { LiveSharder, Sharder } from "dfx/DiscordGateway/Sharder"
-import type { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
 import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
+import * as Schedule from "effect/Schedule"
 
 const fromDispatchFactory =
   <R, E>(
@@ -33,15 +33,10 @@ const handleDispatchFactory =
       if (_.t === event) {
         return handle(_.d as any)
       }
-      return Effect.unit
+      return Effect.unit as any
     })
 
 export interface DiscordGateway {
-  readonly run: Effect.Effect<
-    never,
-    WebSocketError | WebSocketCloseError,
-    never
-  >
   readonly dispatch: Stream.Stream<
     never,
     never,
@@ -77,19 +72,32 @@ export const make = Effect.gen(function* (_) {
   const fromDispatch = fromDispatchFactory(dispatch)
   const handleDispatch = handleDispatchFactory(hub)
 
-  const run = sharder.run(hub, sendQueue)
+  yield* _(
+    sharder.run(hub, sendQueue),
+    Effect.tapErrorCause(_ => Effect.logError("fatal error, restarting", _)),
+    Effect.retry(
+      Schedule.exponential("1 seconds").pipe(
+        Schedule.union(Schedule.spaced("30 seconds")),
+      ),
+    ),
+    Effect.forkScoped,
+  )
 
   return DiscordGateway.of({
-    run,
     dispatch,
     fromDispatch,
     handleDispatch,
     send,
     shards: sharder.shards,
   })
-})
+}).pipe(
+  Effect.annotateLogs({
+    package: "dfx",
+    service: "DiscordGateway",
+  }),
+)
 
 export const LiveDiscordGateway = Layer.provide(
+  Layer.scoped(DiscordGateway, make),
   LiveSharder,
-  Layer.effect(DiscordGateway, make),
 )

package/src/DiscordREST.ts

@@ -255,6 +255,6 @@ export interface DiscordREST
 
 export const DiscordREST = Tag<DiscordREST>()
 export const LiveDiscordREST = Layer.effect(DiscordREST, make).pipe(
-  Layer.use(LiveRateLimiter),
-  Layer.use(Http.client.layer),
+  Layer.provide(LiveRateLimiter),
+  Layer.provide(Http.client.layer),
 )

package/src/Helpers/interactions.ts

@@ -151,7 +151,7 @@ export const resolveValues =
       ),
       Option.bind("r", () => resolved(a)),
       Option.map(({ r, values }) =>
-        Arr.compact(values.map(a => Option.fromNullable(f(a as any, r)))),
+        Arr.getSomes(values.map(a => Option.fromNullable(f(a as any, r)))),
       ),
     )
 

package/src/Interactions/gateway.ts

@@ -2,7 +2,6 @@ import * as Chunk from "effect/Chunk"
 import { Tag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import { pipe } from "effect/Function"
-import type { Cause } from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Queue from "effect/Queue"
@@ -21,6 +20,7 @@ import type { InteractionBuilder } from "dfx/Interactions/index"
 import { builder, Interaction } from "dfx/Interactions/index"
 import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
+import * as Schedule from "effect/Schedule"
 
 export interface RunOpts {
   sync?: boolean
@@ -112,55 +112,55 @@ export const run =
       )
     })
 
-const makeRegistry = Effect.gen(function* (_) {
-  const ref = yield* _(
-    Ref.make(builder as InteractionBuilder<never, never, never>),
-  )
-  const queue = yield* _(
-    Queue.sliding<InteractionBuilder<never, never, never>>(1),
-  )
-
-  const register = <E>(ix: InteractionBuilder<never, E, never>) =>
-    Effect.flatMap(
-      Ref.updateAndGet(ref, _ => _.concat(ix as any)),
-      _ => Queue.offer(queue, _),
+const makeRegistry = (options?: RunOpts) =>
+  Effect.gen(function* (_) {
+    const ref = yield* _(
+      Ref.make(builder as InteractionBuilder<never, never, never>),
+    )
+    const queue = yield* _(
+      Queue.sliding<InteractionBuilder<never, never, never>>(1),
     )
 
-  const run_ = <R, E>(
-    onError: (
-      _: Cause<DiscordRESTError | DefinitionNotFound>,
-    ) => Effect.Effect<R, E, void>,
-    opts?: RunOpts,
-  ) =>
-    EffectUtils.foreverSwitch(Queue.take(queue), ix =>
-      Effect.delay(
-        pipe(ix, run(Effect.catchAllCause(onError), opts)),
-        Duration.seconds(0.1),
+    const register = <E>(ix: InteractionBuilder<never, E, never>) =>
+      Effect.flatMap(
+        Ref.updateAndGet(ref, _ => _.concat(ix as any)),
+        _ => Queue.offer(queue, _),
+      )
+
+    yield* _(
+      EffectUtils.foreverSwitch(Queue.take(queue), ix =>
+        pipe(
+          ix,
+          run(
+            Effect.catchAllCause(_ => Effect.logError("unhandled error", _)),
+            options,
+          ),
+          Effect.delay(Duration.seconds(0.1)),
+        ),
+      ),
+      Effect.tapErrorCause(_ => Effect.logError("registry error", _)),
+      Effect.retry(
+        Schedule.exponential("1 seconds").pipe(
+          Schedule.union(Schedule.spaced("20 seconds")),
+        ),
       ),
+      Effect.forkScoped,
     )
 
-  return { register, run: run_ } as const
-})
+    return { register } as const
+  }).pipe(
+    Effect.annotateLogs({
+      package: "dfx",
+      service: "InteractionsRegistry",
+    }),
+  )
 
 export interface InteractionsRegistry {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
   ) => Effect.Effect<never, never, void>
-
-  readonly run: <R, E>(
-    onError: (
-      _: Cause<DiscordRESTError | DefinitionNotFound>,
-    ) => Effect.Effect<R, E, void>,
-    opts?: RunOpts,
-  ) => Effect.Effect<
-    DiscordREST | DiscordGateway | Exclude<R, Discord.Interaction>,
-    DiscordRESTError | Http.error.ResponseError | E,
-    never
-  >
 }
 
 export const InteractionsRegistry = Tag<InteractionsRegistry>()
-export const InteractionsRegistryLive = Layer.effect(
-  InteractionsRegistry,
-  makeRegistry,
-)
+export const InteractionsRegistryLive = (options?: RunOpts) =>
+  Layer.scoped(InteractionsRegistry, makeRegistry(options))

package/src/gateway.ts

@@ -14,8 +14,6 @@ import * as SendEvent from "dfx/DiscordGateway/Shard/sendEvents"
 import * as ShardStore from "dfx/DiscordGateway/ShardStore"
 import { LiveMemoryShardStore } from "dfx/DiscordGateway/ShardStore"
 import * as WS from "dfx/DiscordGateway/WS"
-import { InteractionsRegistryLive } from "dfx/gateway"
-import type { InteractionsRegistry } from "dfx/gateway"
 import type { RateLimiter } from "dfx/RateLimit"
 import { LiveMemoryRateLimitStore, LiveRateLimiter } from "dfx/RateLimit"
 
@@ -30,21 +28,18 @@ export {
 export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore, WS }
 
 export const MemoryRateLimit = Layer.provide(
-  LiveMemoryRateLimitStore,
   LiveRateLimiter,
+  LiveMemoryRateLimitStore,
 )
 
-export const MemoryBot = Layer.provide(
-  Layer.mergeAll(
-    LiveMemoryShardStore,
-    LiveMemoryRateLimitStore,
-    LiveJsonDiscordWSCodec,
-  ),
-  Layer.mergeAll(
-    Layer.provideMerge(LiveDiscordREST, LiveDiscordGateway),
-    MemoryRateLimit,
-    InteractionsRegistryLive,
-  ),
+export const MemoryBot = Layer.mergeAll(
+  MemoryRateLimit,
+  LiveDiscordGateway,
+).pipe(
+  Layer.provideMerge(LiveDiscordREST),
+  Layer.provide(LiveJsonDiscordWSCodec),
+  Layer.provide(LiveMemoryRateLimitStore),
+  Layer.provide(LiveMemoryShardStore),
 )
 
 export const gatewayLayer = (
@@ -54,7 +49,6 @@ export const gatewayLayer = (
   ConfigError.ConfigError,
   | RateLimiter
   | Log.Log
-  | InteractionsRegistry
   | DiscordREST
   | DiscordGateway
   | DiscordConfig.DiscordConfig
@@ -65,7 +59,7 @@ export const gatewayLayer = (
       Effect.map(config => {
         const LiveLog = config.debug ? Log.LiveLogDebug : Log.LiveLog
         const LiveConfig = Layer.succeed(DiscordConfig.DiscordConfig, config)
-        return Layer.provideMerge(Layer.merge(LiveLog, LiveConfig), MemoryBot)
+        return Layer.provideMerge(MemoryBot, Layer.merge(LiveLog, LiveConfig))
       }),
     ),
   )