dfx 0.76.1 → 0.77.1

package/mjs/webhooks.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"webhooks.mjs","names":["Config","Effect","Layer","DiscordConfig","LiveDiscordREST","makeConfigLayer","Log","LiveMemoryRateLimitStore","LiveRateLimiter","BadWebhookSignature","makeHandler","makeSimpleHandler","WebhookConfig","WebhookParseError","MemoryRateLimit","provide","MemoryREST","webhookLayer","options","config","make","LiveConfig","succeed","LiveWebhook","LiveLog","debug","LiveLogDebug","LiveEnv","mergeAll","merge","webhookLayerConfig","unwrapEffect","map","unwrap"],"sources":["../src/webhooks.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,eAAe;AAEvC,OAAO,KAAKC,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,KAAK,MAAM,cAAc;AACrC,OAAO,KAAKC,aAAa,MAAM,mBAAmB;AAElD,SAASC,eAAe,QAAQ,iBAAiB;AAEjD,SAASC,eAAe,QAAQ,0BAA0B;AAC1D,OAAO,KAAKC,GAAG,MAAM,SAAS;AAE9B,SAASC,wBAAwB,EAAEC,eAAe,QAAQ,eAAe;AAEzE,SACEC,mBAAmB,EACnBJ,eAAe,EACfK,WAAW,EACXC,iBAAiB,EACjBC,aAAa,EACbC,iBAAiB,QACZ,0BAA0B;AAEjC,OAAO,MAAMC,eAAe,gBAAGZ,KAAK,CAACa,OAAO,CAC1CP,eAAe,EACfD,wBAAwB,CACzB;AAED,OAAO,MAAMS,UAAU,gBAAGd,KAAK,CAACa,OAAO,CACrCX,eAAe,EACfG,wBAAwB,CACzB;AAED,OAAO,MAAMU,YAAY,GACvBC,OAAgD,IAK9C;EACF,MAAMC,MAAM,GAAGhB,aAAa,CAACiB,IAAI,CAACF,OAAO,CAAC;EAC1C,MAAMG,UAAU,GAAGnB,KAAK,CAACoB,OAAO,CAACnB,aAAa,CAACA,aAAa,EAAEgB,MAAM,CAAC;EACrE,MAAMI,WAAW,GAAGlB,eAAe,CAACa,OAAO,CAAC;EAC5C,MAAMM,OAAO,GAAGL,MAAM,CAACM,KAAK,GAAGnB,GAAG,CAACoB,YAAY,GAAGpB,GAAG,CAACkB,OAAO;EAC7D,MAAMG,OAAO,GAAGzB,KAAK,CAACa,OAAO,CAC3Bb,KAAK,CAAC0B,QAAQ,CAACZ,UAAU,EAAEO,WAAW,EAAET,eAAe,CAAC,EACxDZ,KAAK,CAAC2B,KAAK,CAACL,OAAO,EAAEH,UAAU,CAAC,CACjC;EAED,OAAOM,OAAO;AAChB,CAAC;AAED,OAAO,MAAMG,kBAAkB,GAC7BX,MAAmE,IAMnEjB,KAAK,CAAC6B,YAAY,CAChB9B,MAAM,CAAC+B,GAAG,CAAC/B,MAAM,CAACkB,MAAM,CAACnB,MAAM,CAACiC,MAAM,CAACd,MAAM,CAAC,CAAC,EAAEF,YAAY,CAAC,CAC/D"}
+{"version":3,"file":"webhooks.mjs","names":["DiscordRESTLive","Log","LiveMemoryRateLimitStore","MemoryRateLimitStoreLive","RateLimiterLive","Layer","BadWebhookSignature","WebhookConfig","WebhookParseError","makeHandler","makeSimpleHandler","layer","webhookLayer","layerConfig","webhookLayerConfig","DiscordLive","mergeAll","pipe","provide","provideMerge","LogLive"],"sources":["../src/webhooks.ts"],"sourcesContent":[null],"mappings":"AAAA,SAASA,eAAe,QAAQ,iBAAiB;AACjD,OAAO,KAAKC,GAAG,MAAM,SAAS;AAC9B,SACEC,wBAAwB,IAAIC,wBAAwB,EACpDC,eAAkC,QAC7B,eAAe;AACtB,OAAO,KAAKC,KAAK,MAAM,cAAc;AAErC,SACEC,mBAAmB,EACnBC,aAAa,EACbC,iBAAiB,EACjBC,WAAW,EACXC,iBAAiB,EACjBC,KAAK,IAAIC,YAAY,EACrBC,WAAW,IAAIC,kBAAkB,QAC5B,0BAA0B;AAEjC,OAAO,MAAMC,WAAW,gBAAGV,KAAK,CAACW,QAAQ,CACvChB,eAAe,EACfI,eAAe,CAChB,CAACa,IAAI,eAACZ,KAAK,CAACa,OAAO,CAACf,wBAAwB,CAAC,eAAEE,KAAK,CAACc,YAAY,CAAClB,GAAG,CAACmB,OAAO,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dfx",
-  "version": "0.76.1",
+  "version": "0.77.1",
   "description": "Effect-TS discord library",
   "license": "MIT",
   "repository": {
@@ -48,6 +48,6 @@
     "utf-8-validate": "^6.0.3",
     "zlib-sync": "^0.1.9"
   },
-  "gitHead": "ea9623e85af43ad3f27a23a1e7e1171c34e358cd",
+  "gitHead": "89968da1bb61fcedd9e26605907021ce1c11b27c",
   "main": "./index.js"
 }

package/src/DiscordConfig.ts

@@ -60,12 +60,12 @@ export const make = ({
   },
 })
 
-export const makeLayer = (
+export const layer = (
   opts: MakeOpts,
 ): Layer.Layer<never, never, DiscordConfig> =>
   Layer.succeed(DiscordConfig, make(opts))
 
-export const makeFromConfig = (
+export const layerConfig = (
   _: Config.Config.Wrap<MakeOpts>,
 ): Layer.Layer<never, ConfigError.ConfigError, DiscordConfig> =>
   Layer.effect(DiscordConfig, Effect.map(Effect.config(Config.unwrap(_)), make))

package/src/DiscordGateway/DiscordWS.ts

@@ -2,7 +2,7 @@ import { Tag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
-import { LiveWS, Reconnect, WS } from "dfx/DiscordGateway/WS"
+import { WSLive, Reconnect, WS } from "dfx/DiscordGateway/WS"
 import type * as Discord from "dfx/types"
 import type WebSocket from "isomorphic-ws"
 
@@ -69,7 +69,7 @@ const make = Effect.gen(function* (_) {
 
 export interface DiscordWS extends Effect.Effect.Success<typeof make> {}
 export const DiscordWS = Tag<DiscordWS>()
-export const LiveDiscordWS = Layer.provide(
+export const DiscordWSLive = Layer.provide(
   Layer.effect(DiscordWS, make),
-  LiveWS,
+  WSLive,
 )

package/src/DiscordGateway/Shard.ts

@@ -11,14 +11,14 @@ import * as Queue from "effect/Queue"
 import * as Ref from "effect/Ref"
 import { DiscordConfig } from "dfx/DiscordConfig"
 import type { Message } from "dfx/DiscordGateway/DiscordWS"
-import { DiscordWS, LiveDiscordWS } from "dfx/DiscordGateway/DiscordWS"
+import { DiscordWS, DiscordWSLive } from "dfx/DiscordGateway/DiscordWS"
 import * as Heartbeats from "dfx/DiscordGateway/Shard/heartbeats"
 import * as Identify from "dfx/DiscordGateway/Shard/identify"
 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 { RateLimiterLive, RateLimiter } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
 
 const enum Phase {
@@ -191,9 +191,9 @@ 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(
+export const ShardLive = Layer.provide(
   Layer.effect(Shard, make),
-  Layer.merge(LiveDiscordWS, LiveRateLimiter),
+  Layer.merge(DiscordWSLive, RateLimiterLive),
 )
 
 export interface RunningShard

package/src/DiscordGateway/ShardStore.ts

@@ -37,4 +37,4 @@ const memoryStore = (): ShardStore => {
   }
 }
 
-export const LiveMemoryShardStore = Layer.sync(ShardStore, memoryStore)
+export const MemoryShardStoreLive = Layer.sync(ShardStore, memoryStore)

package/src/DiscordGateway/Sharder.ts

@@ -13,11 +13,11 @@ import * as Ref from "effect/Ref"
 import * as Schedule from "effect/Schedule"
 import { DiscordConfig } from "dfx/DiscordConfig"
 import type { RunningShard } from "dfx/DiscordGateway/Shard"
-import { LiveShard, Shard } from "dfx/DiscordGateway/Shard"
+import { ShardLive, Shard } from "dfx/DiscordGateway/Shard"
 import { ShardStore } from "dfx/DiscordGateway/ShardStore"
 import type { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
 import { DiscordREST } from "dfx/DiscordREST"
-import { LiveRateLimiter, RateLimiter } from "dfx/RateLimit"
+import { RateLimiterLive, RateLimiter } from "dfx/RateLimit"
 import type * as Discord from "dfx/types"
 
 const claimRepeatPolicy = Schedule.spaced("3 minutes").pipe(
@@ -134,7 +134,7 @@ const make = Effect.gen(function* (_) {
 
 export interface Sharder extends Effect.Effect.Success<typeof make> {}
 export const Sharder = Tag<Sharder>()
-export const LiveSharder = Layer.provide(
+export const SharedLive = Layer.provide(
   Layer.effect(Sharder, make),
-  Layer.merge(LiveRateLimiter, LiveShard),
+  Layer.merge(RateLimiterLive, ShardLive),
 )

package/src/DiscordGateway/WS.ts

@@ -151,4 +151,4 @@ const make = Effect.gen(function* (_) {
 
 export interface WS extends Effect.Effect.Success<typeof make> {}
 export const WS = Tag<WS>()
-export const LiveWS = Layer.effect(WS, make)
+export const WSLive = Layer.effect(WS, make)

package/src/DiscordGateway.ts

@@ -6,7 +6,7 @@ import * as Layer from "effect/Layer"
 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 { SharedLive, Sharder } from "dfx/DiscordGateway/Sharder"
 import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
 import * as Schedule from "effect/Schedule"
@@ -97,7 +97,7 @@ export const make = Effect.gen(function* (_) {
   }),
 )
 
-export const LiveDiscordGateway = Layer.provide(
+export const DiscordGatewayLive = Layer.provide(
   Layer.scoped(DiscordGateway, make),
-  LiveSharder,
+  SharedLive,
 )

package/src/DiscordREST.ts

@@ -17,7 +17,7 @@ import {
   routeFromConfig,
 } from "dfx/DiscordREST/utils"
 import { Log } from "dfx/Log"
-import { LiveRateLimiter, RateLimiter, RateLimitStore } from "dfx/RateLimit"
+import { RateLimiterLive, RateLimiter, RateLimitStore } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
 import { LIB_VERSION } from "dfx/version"
 
@@ -254,7 +254,7 @@ export interface DiscordREST
 }
 
 export const DiscordREST = Tag<DiscordREST>()
-export const LiveDiscordREST = Layer.effect(DiscordREST, make).pipe(
-  Layer.provide(LiveRateLimiter),
+export const DiscordRESTLive = Layer.effect(DiscordREST, make).pipe(
+  Layer.provide(RateLimiterLive),
   Layer.provide(Http.client.layer),
 )

package/src/Interactions/gateway.ts

@@ -21,14 +21,17 @@ 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"
+import { globalValue } from "effect/GlobalValue"
+import * as FiberRef from "effect/FiberRef"
 
-export interface RunOpts {
-  sync?: boolean
-}
+export const interactionsSync: FiberRef.FiberRef<boolean> = globalValue(
+  "dfx/Interactions/sync",
+  () => FiberRef.unsafeMake(true),
+)
+
+export const setInteractionsSync = (enabled: boolean) =>
+  Layer.locally(interactionsSync, enabled)
 
-/**
- * @tsplus pipeable dfx/InteractionBuilder runGateway
- */
 export const run =
   <R, R2, E, TE, E2>(
     postHandler: (
@@ -38,7 +41,6 @@ export const run =
         void
       >,
     ) => Effect.Effect<R2, E2, void>,
-    { sync = true }: RunOpts = {},
   ) =>
   (
     ix: InteractionBuilder<R, E, TE>,
@@ -100,6 +102,8 @@ export const run =
         Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
       )
 
+      const sync = yield* _(FiberRef.get(interactionsSync))
+
       return yield* _(
         sync
           ? Effect.forever(
@@ -112,49 +116,45 @@ export const run =
       )
     })
 
-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 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 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)),
-        ),
+  yield* _(
+    EffectUtils.foreverSwitch(Queue.take(queue), ix =>
+      pipe(
+        ix,
+        run(Effect.catchAllCause(_ => Effect.logError("unhandled error", _))),
+        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.tapErrorCause(_ => Effect.logError("registry error", _)),
+    Effect.retry(
+      Schedule.exponential("1 seconds").pipe(
+        Schedule.union(Schedule.spaced("20 seconds")),
       ),
-      Effect.forkScoped,
-    )
-
-    return { register } as const
-  }).pipe(
-    Effect.annotateLogs({
-      package: "dfx",
-      service: "InteractionsRegistry",
-    }),
+    ),
+    Effect.forkScoped,
   )
 
+  return { register } as const
+}).pipe(
+  Effect.annotateLogs({
+    package: "dfx",
+    service: "InteractionsRegistry",
+  }),
+)
+
 export interface InteractionsRegistry {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
@@ -162,5 +162,7 @@ export interface InteractionsRegistry {
 }
 
 export const InteractionsRegistry = Tag<InteractionsRegistry>()
-export const InteractionsRegistryLive = (options?: RunOpts) =>
-  Layer.scoped(InteractionsRegistry, makeRegistry(options))
+export const InteractionsRegistryLive = Layer.scoped(
+  InteractionsRegistry,
+  makeRegistry,
+)

package/src/Interactions/webhook.ts

@@ -71,10 +71,10 @@ const makeConfig = ({
 export interface WebhookConfig extends ReturnType<typeof makeConfig> {}
 export const WebhookConfig = Tag<WebhookConfig>()
 
-export const makeConfigLayer = (opts: MakeConfigOpts) =>
+export const layer = (opts: MakeConfigOpts) =>
   Layer.succeed(WebhookConfig, makeConfig(opts))
 
-export const makeFromConfig: (
+export const layerConfig: (
   a: Config.Config<MakeConfigOpts>,
 ) => Layer.Layer<never, ConfigError.ConfigError, WebhookConfig> = (
   a: Config.Config<MakeConfigOpts>,

package/src/Log.ts

@@ -1,3 +1,4 @@
+import { DiscordConfig } from "dfx/DiscordConfig"
 import { Tag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
@@ -17,5 +18,7 @@ const make = (debug = false) => ({
 
 export interface Log extends ReturnType<typeof make> {}
 export const Log = Tag<Log>()
-export const LiveLog = Layer.succeed(Log, make(false))
-export const LiveLogDebug = Layer.succeed(Log, make(true))
+export const LogLive = Layer.effect(
+  Log,
+  Effect.map(DiscordConfig, config => make(config.debug)),
+)

package/src/RateLimit.ts

@@ -79,4 +79,4 @@ const makeLimiter = Effect.gen(function* (_) {
 export interface RateLimiter
   extends Effect.Effect.Success<typeof makeLimiter> {}
 export const RateLimiter = Tag<RateLimiter>()
-export const LiveRateLimiter = Layer.effect(RateLimiter, makeLimiter)
+export const RateLimiterLive = Layer.effect(RateLimiter, makeLimiter)

package/src/gateway.ts

@@ -1,65 +1,47 @@
-import * as Config from "effect/Config"
-import type * as ConfigError from "effect/ConfigError"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import type { DiscordREST } from "dfx"
-import { DiscordConfig, LiveDiscordREST, Log } from "dfx"
+import { LiveDiscordREST as DiscordRESTLive } from "dfx"
 import * as CachePrelude from "dfx/Cache/prelude"
-import type { DiscordGateway } from "dfx/DiscordGateway"
-import { LiveDiscordGateway } from "dfx/DiscordGateway"
+import { DiscordGatewayLive } from "dfx/DiscordGateway"
 import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
-import { LiveJsonDiscordWSCodec } from "dfx/DiscordGateway/DiscordWS"
+import { LiveJsonDiscordWSCodec as JsonDiscordWSCodecLive } from "dfx/DiscordGateway/DiscordWS"
 import * as Shard from "dfx/DiscordGateway/Shard"
 import * as SendEvent from "dfx/DiscordGateway/Shard/sendEvents"
 import * as ShardStore from "dfx/DiscordGateway/ShardStore"
-import { LiveMemoryShardStore } from "dfx/DiscordGateway/ShardStore"
+import { MemoryShardStoreLive as MemoryShardStoreLive } from "dfx/DiscordGateway/ShardStore"
 import * as WS from "dfx/DiscordGateway/WS"
-import type { RateLimiter } from "dfx/RateLimit"
-import { LiveMemoryRateLimitStore, LiveRateLimiter } from "dfx/RateLimit"
+import { LogLive } from "dfx/Log"
+import {
+  LiveMemoryRateLimitStore as MemoryRateLimitStoreLive,
+  RateLimiterLive as RateLimiterLive,
+} from "dfx/RateLimit"
+import * as Layer from "effect/Layer"
+import { InteractionsRegistryLive } from "./gateway"
 
-export { DiscordGateway, LiveDiscordGateway } from "dfx/DiscordGateway"
+export {
+  DiscordGateway,
+  DiscordGatewayLive as LiveDiscordGateway,
+} from "dfx/DiscordGateway"
 
 export {
   InteractionsRegistry,
   InteractionsRegistryLive,
+  interactionsSync,
   run as runIx,
+  setInteractionsSync,
 } from "dfx/Interactions/gateway"
 
 export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore, WS }
 
-export const MemoryRateLimit = Layer.provide(
-  LiveRateLimiter,
-  LiveMemoryRateLimitStore,
-)
-
-export const MemoryBot = Layer.mergeAll(
-  MemoryRateLimit,
-  LiveDiscordGateway,
+export const DiscordLive = Layer.mergeAll(
+  RateLimiterLive,
+  DiscordGatewayLive,
 ).pipe(
-  Layer.provideMerge(LiveDiscordREST),
-  Layer.provide(LiveJsonDiscordWSCodec),
-  Layer.provide(LiveMemoryRateLimitStore),
-  Layer.provide(LiveMemoryShardStore),
+  Layer.provideMerge(DiscordRESTLive),
+  Layer.provide(JsonDiscordWSCodecLive),
+  Layer.provide(MemoryRateLimitStoreLive),
+  Layer.provide(MemoryShardStoreLive),
+  Layer.provideMerge(LogLive),
 )
 
-export const gatewayLayer = (
-  config: Config.Config.Wrap<DiscordConfig.MakeOpts>,
-): Layer.Layer<
-  never,
-  ConfigError.ConfigError,
-  | RateLimiter
-  | Log.Log
-  | DiscordREST
-  | DiscordGateway
-  | DiscordConfig.DiscordConfig
-> =>
-  Layer.unwrapEffect(
-    Effect.config(Config.unwrap(config)).pipe(
-      Effect.map(DiscordConfig.make),
-      Effect.map(config => {
-        const LiveLog = config.debug ? Log.LiveLogDebug : Log.LiveLog
-        const LiveConfig = Layer.succeed(DiscordConfig.DiscordConfig, config)
-        return Layer.provideMerge(MemoryBot, Layer.merge(LiveLog, LiveConfig))
-      }),
-    ),
-  )
+export const DiscordIxLive = InteractionsRegistryLive.pipe(
+  Layer.provideMerge(DiscordLive),
+)

package/src/index.ts

@@ -10,12 +10,15 @@ import * as Ix from "dfx/Interactions/index"
 import * as Log from "dfx/Log"
 import * as Discord from "dfx/types"
 
-export { DiscordREST, LiveDiscordREST } from "dfx/DiscordREST"
+export {
+  DiscordREST,
+  DiscordRESTLive as LiveDiscordREST,
+} from "dfx/DiscordREST"
 
 export {
   BucketDetails,
   LiveMemoryRateLimitStore,
-  LiveRateLimiter,
+  RateLimiterLive as LiveRateLimiter,
   RateLimiter,
   RateLimitStore,
 } from "dfx/RateLimit"

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.76.1";
+export const LIB_VERSION = "0.77.1";

package/src/webhooks.ts

@@ -1,61 +1,22 @@
-import * as Config from "effect/Config"
-import type * as ConfigError from "effect/ConfigError"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as DiscordConfig from "dfx/DiscordConfig"
-import type { DiscordREST } from "dfx/DiscordREST"
-import { LiveDiscordREST } from "dfx/DiscordREST"
-import type { MakeConfigOpts, WebhookConfig } from "dfx/Interactions/webhook"
-import { makeConfigLayer } from "dfx/Interactions/webhook"
+import { DiscordRESTLive } from "dfx/DiscordREST"
 import * as Log from "dfx/Log"
-import type { RateLimiter } from "dfx/RateLimit"
-import { LiveMemoryRateLimitStore, LiveRateLimiter } from "dfx/RateLimit"
+import {
+  LiveMemoryRateLimitStore as MemoryRateLimitStoreLive,
+  RateLimiterLive as RateLimiterLive,
+} from "dfx/RateLimit"
+import * as Layer from "effect/Layer"
 
 export {
   BadWebhookSignature,
-  makeConfigLayer,
-  makeHandler,
-  makeSimpleHandler,
   WebhookConfig,
   WebhookParseError,
+  makeHandler,
+  makeSimpleHandler,
+  layer as webhookLayer,
+  layerConfig as webhookLayerConfig,
 } from "dfx/Interactions/webhook"
 
-export const MemoryRateLimit = Layer.provide(
-  LiveRateLimiter,
-  LiveMemoryRateLimitStore,
-)
-
-export const MemoryREST = Layer.provide(
-  LiveDiscordREST,
-  LiveMemoryRateLimitStore,
-)
-
-export const webhookLayer = (
-  options: DiscordConfig.MakeOpts & MakeConfigOpts,
-): Layer.Layer<
-  never,
-  ConfigError.ConfigError,
-  RateLimiter | DiscordREST | WebhookConfig
-> => {
-  const config = DiscordConfig.make(options)
-  const LiveConfig = Layer.succeed(DiscordConfig.DiscordConfig, config)
-  const LiveWebhook = makeConfigLayer(options)
-  const LiveLog = config.debug ? Log.LiveLogDebug : Log.LiveLog
-  const LiveEnv = Layer.provide(
-    Layer.mergeAll(MemoryREST, LiveWebhook, MemoryRateLimit),
-    Layer.merge(LiveLog, LiveConfig),
-  )
-
-  return LiveEnv
-}
-
-export const webhookLayerConfig = (
-  config: Config.Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>,
-): Layer.Layer<
-  never,
-  ConfigError.ConfigError,
-  RateLimiter | DiscordREST | WebhookConfig
-> =>
-  Layer.unwrapEffect(
-    Effect.map(Effect.config(Config.unwrap(config)), webhookLayer),
-  )
+export const DiscordLive = Layer.mergeAll(
+  DiscordRESTLive,
+  RateLimiterLive,
+).pipe(Layer.provide(MemoryRateLimitStoreLive), Layer.provideMerge(Log.LogLive))

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LIB_VERSION = "0.76.1";
+export declare const LIB_VERSION = "0.77.1";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.LIB_VERSION = void 0;
-const LIB_VERSION = exports.LIB_VERSION = "0.76.1";
+const LIB_VERSION = exports.LIB_VERSION = "0.77.1";
 //# sourceMappingURL=version.js.map

package/webhooks.d.ts

@@ -1,14 +1,5 @@
-import * as Config from "effect/Config";
-import type * as ConfigError from "effect/ConfigError";
-import * as Layer from "effect/Layer";
-import * as DiscordConfig from "dfx/DiscordConfig";
-import type { DiscordREST } from "dfx/DiscordREST";
-import type { MakeConfigOpts, WebhookConfig } from "dfx/Interactions/webhook";
 import * as Log from "dfx/Log";
-import type { RateLimiter } from "dfx/RateLimit";
-export { BadWebhookSignature, makeConfigLayer, makeHandler, makeSimpleHandler, WebhookConfig, WebhookParseError, } from "dfx/Interactions/webhook";
-export declare const MemoryRateLimit: Layer.Layer<Log.Log, never, RateLimiter>;
-export declare const MemoryREST: Layer.Layer<DiscordConfig.DiscordConfig | Log.Log, never, DiscordREST>;
-export declare const webhookLayer: (options: DiscordConfig.MakeOpts & MakeConfigOpts) => Layer.Layer<never, ConfigError.ConfigError, RateLimiter | DiscordREST | WebhookConfig>;
-export declare const webhookLayerConfig: (config: Config.Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>) => Layer.Layer<never, ConfigError.ConfigError, RateLimiter | DiscordREST | WebhookConfig>;
+import * as Layer from "effect/Layer";
+export { BadWebhookSignature, WebhookConfig, WebhookParseError, makeHandler, makeSimpleHandler, layer as webhookLayer, layerConfig as webhookLayerConfig, } from "dfx/Interactions/webhook";
+export declare const DiscordLive: Layer.Layer<import("./DiscordConfig").DiscordConfig, never, Log.Log | import("dfx/RateLimit").RateLimiter | import("dfx/DiscordREST").DiscordREST>;
 //# sourceMappingURL=webhooks.d.ts.map

package/webhooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["./src/webhooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAA;AAEtD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,aAAa,MAAM,mBAAmB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAElD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE7E,OAAO,KAAK,GAAG,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAGhD,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,iBAAiB,GAClB,MAAM,0BAA0B,CAAA;AAEjC,eAAO,MAAM,eAAe,0CAG3B,CAAA;AAED,eAAO,MAAM,UAAU,wEAGtB,CAAA;AAED,eAAO,MAAM,YAAY,YACd,cAAc,QAAQ,GAAG,cAAc,KAC/C,WAAW,CACZ,KAAK,EACL,uBAAuB,EACvB,WAAW,GAAG,WAAW,GAAG,aAAa,CAY1C,CAAA;AAED,eAAO,MAAM,kBAAkB,WACrB,aAAa,CAAC,IAAI,CAAC,cAAc,QAAQ,GAAG,cAAc,CAAC,KAClE,WAAW,CACZ,KAAK,EACL,uBAAuB,EACvB,WAAW,GAAG,WAAW,GAAG,aAAa,CAIxC,CAAA"}
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["./src/webhooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,SAAS,CAAA;AAK9B,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,KAAK,IAAI,YAAY,EACrB,WAAW,IAAI,kBAAkB,GAClC,MAAM,0BAA0B,CAAA;AAEjC,eAAO,MAAM,WAAW,oJAGwD,CAAA"}

package/webhooks.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "BadWebhookSignature", {
     return _webhook.BadWebhookSignature;
   }
 });
-exports.MemoryRateLimit = exports.MemoryREST = void 0;
+exports.DiscordLive = void 0;
 Object.defineProperty(exports, "WebhookConfig", {
   enumerable: true,
   get: function () {
@@ -22,12 +22,6 @@ Object.defineProperty(exports, "WebhookParseError", {
     return _webhook.WebhookParseError;
   }
 });
-Object.defineProperty(exports, "makeConfigLayer", {
-  enumerable: true,
-  get: function () {
-    return _webhook.makeConfigLayer;
-  }
-});
 Object.defineProperty(exports, "makeHandler", {
   enumerable: true,
   get: function () {
@@ -40,28 +34,24 @@ Object.defineProperty(exports, "makeSimpleHandler", {
     return _webhook.makeSimpleHandler;
   }
 });
-exports.webhookLayerConfig = exports.webhookLayer = void 0;
-var Config = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Config"));
-var Effect = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Effect"));
-var Layer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Layer"));
-var DiscordConfig = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("dfx/DiscordConfig"));
+Object.defineProperty(exports, "webhookLayer", {
+  enumerable: true,
+  get: function () {
+    return _webhook.layer;
+  }
+});
+Object.defineProperty(exports, "webhookLayerConfig", {
+  enumerable: true,
+  get: function () {
+    return _webhook.layerConfig;
+  }
+});
 var _DiscordREST = /*#__PURE__*/require("dfx/DiscordREST");
-var _webhook = /*#__PURE__*/require("dfx/Interactions/webhook");
 var Log = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("dfx/Log"));
 var _RateLimit = /*#__PURE__*/require("dfx/RateLimit");
+var Layer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Layer"));
+var _webhook = /*#__PURE__*/require("dfx/Interactions/webhook");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const MemoryRateLimit = exports.MemoryRateLimit = /*#__PURE__*/Layer.provide(_RateLimit.LiveRateLimiter, _RateLimit.LiveMemoryRateLimitStore);
-const MemoryREST = exports.MemoryREST = /*#__PURE__*/Layer.provide(_DiscordREST.LiveDiscordREST, _RateLimit.LiveMemoryRateLimitStore);
-const webhookLayer = options => {
-  const config = DiscordConfig.make(options);
-  const LiveConfig = Layer.succeed(DiscordConfig.DiscordConfig, config);
-  const LiveWebhook = (0, _webhook.makeConfigLayer)(options);
-  const LiveLog = config.debug ? Log.LiveLogDebug : Log.LiveLog;
-  const LiveEnv = Layer.provide(Layer.mergeAll(MemoryREST, LiveWebhook, MemoryRateLimit), Layer.merge(LiveLog, LiveConfig));
-  return LiveEnv;
-};
-exports.webhookLayer = webhookLayer;
-const webhookLayerConfig = config => Layer.unwrapEffect(Effect.map(Effect.config(Config.unwrap(config)), webhookLayer));
-exports.webhookLayerConfig = webhookLayerConfig;
+const DiscordLive = exports.DiscordLive = /*#__PURE__*/Layer.mergeAll(_DiscordREST.DiscordRESTLive, _RateLimit.RateLimiterLive).pipe( /*#__PURE__*/Layer.provide(_RateLimit.LiveMemoryRateLimitStore), /*#__PURE__*/Layer.provideMerge(Log.LogLive));
 //# sourceMappingURL=webhooks.js.map