dfx 0.51.0 → 0.51.2

package/src/Log.ts

@@ -1,3 +1,7 @@
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import { Tag } from "@effect/data/Context"
+
 const make = (debug = false) => ({
   info: (...args: any[]) =>
     Effect.sync(() => {

package/src/RateLimit/memory.ts

@@ -1,4 +1,6 @@
-import { BucketDetails, RateLimitStore } from "../RateLimit.js"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import { BucketDetails, RateLimitStore } from "dfx/RateLimit"
 
 interface Counter {
   count: number
@@ -11,10 +13,13 @@ export const make = (): RateLimitStore => {
   const counters = new Map<string, Counter>()
 
   const getCounter = (key: string) =>
-    Maybe.fromNullable(counters.get(key)).filter(c => c.expires > Date.now())
+    Option.filter(
+      Option.fromNullable(counters.get(key)),
+      c => c.expires > Date.now(),
+    )
 
   const getBucketForRoute = (route: string) =>
-    Effect.sync(() => Maybe.fromNullable(buckets.get(routes.get(route)!)))
+    Effect.sync(() => Option.fromNullable(buckets.get(routes.get(route)!)))
 
   return {
     hasBucket: key => Effect.sync(() => buckets.has(key)),
@@ -40,7 +45,8 @@ export const make = (): RateLimitStore => {
       Effect.sync(() => {
         const now = Date.now()
         const perRequest = Math.ceil(window / limit)
-        const counter = getCounter(key).getOrElse(
+        const counter = Option.getOrElse(
+          getCounter(key),
           (): Counter => ({
             expires: now,
             count: 0,

package/src/RateLimit/utils.ts

@@ -1,4 +1,4 @@
-import { millis, zero } from "@effect/data/Duration"
+import { Duration, millis, zero } from "@effect/data/Duration"
 
 export const delayFrom = (
   window: number,

package/src/RateLimit.ts

@@ -1,6 +1,11 @@
-import { delayFrom } from "./RateLimit/utils.js"
-import * as Memory from "./RateLimit/memory.js"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
 import { Log } from "dfx/Log"
+import * as Memory from "dfx/RateLimit/memory"
+import { delayFrom } from "dfx/RateLimit/utils"
 
 export type BucketDetails = {
   key: "global" | string
@@ -9,61 +14,69 @@ export type BucketDetails = {
 }
 
 export interface RateLimitStore {
-  hasBucket: (bucketKey: string) => Effect<never, never, boolean>
+  readonly hasBucket: (
+    bucketKey: string,
+  ) => Effect.Effect<never, never, boolean>
 
-  putBucket: (bucket: BucketDetails) => Effect<never, never, void>
+  readonly putBucket: (
+    bucket: BucketDetails,
+  ) => Effect.Effect<never, never, void>
 
-  getBucketForRoute: (
+  readonly getBucketForRoute: (
     route: string,
-  ) => Effect<never, never, Maybe<BucketDetails>>
+  ) => Effect.Effect<never, never, Option.Option<BucketDetails>>
 
-  putBucketRoute: (
+  readonly putBucketRoute: (
     route: string,
     bucketKey: string,
-  ) => Effect<never, never, void>
+  ) => Effect.Effect<never, never, void>
 
-  incrementCounter: (
+  readonly incrementCounter: (
     key: string,
     window: number,
     limit: number,
-  ) => Effect<never, never, readonly [count: number, ttl: number]>
+  ) => Effect.Effect<never, never, readonly [count: number, ttl: number]>
 
-  removeCounter: (key: string) => Effect<never, never, void>
+  readonly removeCounter: (key: string) => Effect.Effect<never, never, void>
 }
 
 export const RateLimitStore = Tag<RateLimitStore>()
 export const LiveMemoryRateLimitStore = Layer.sync(RateLimitStore, Memory.make)
 
-const makeLimiter = Do($ => {
-  const store = $(RateLimitStore.accessWith(identity))
-  const log = $(Log.accessWith(identity))
+const makeLimiter = Effect.gen(function* (_) {
+  const store = yield* _(RateLimitStore)
+  const log = yield* _(Log)
 
   const maybeWait = (
     key: string,
-    window: Duration,
+    window: Duration.Duration,
     limit: number,
     multiplier = 1.05,
   ) => {
-    const windowMs = window.toMillis * multiplier
+    const windowMs = Duration.toMillis(window) * multiplier
 
-    return store
-      .incrementCounter(key, windowMs, limit)
-      .map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl))
-      .tap(d =>
+    return store.incrementCounter(key, windowMs, limit).pipe(
+      Effect.map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl)),
+      Effect.tap(d =>
         log.debug("RateLimitStore maybeWait", {
           key,
-          window: window.toMillis,
+          window: Duration.toMillis(window),
           windowMs,
           limit,
-          delay: d.toMillis,
+          delay: Duration.toMillis(d),
         }),
-      )
-      .tap(_ => (_.toMillis === 0 ? Effect.unit : Effect.sleep(_))).asUnit
+      ),
+      Effect.tap(_ =>
+        Duration.toMillis(_) === 0 ? Effect.unit : Effect.sleep(_),
+      ),
+      Effect.asUnit,
+    )
   }
 
   return { maybeWait }
 })
 
-export interface RateLimiter extends Effect.Success<typeof makeLimiter> {}
+export interface RateLimiter
+  extends Effect.Effect.Success<typeof makeLimiter> {}
 export const RateLimiter = Tag<RateLimiter>()
 export const LiveRateLimiter = Layer.effect(RateLimiter, makeLimiter)

package/src/gateway.ts

@@ -1,41 +1,78 @@
+import type { HttpRequestExecutor } from "@effect-http/client"
 import { LiveFetchRequestExecutor } from "@effect-http/client"
+import * as Config from "@effect/io/Config"
+import type * as ConfigError from "@effect/io/Config/Error"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import type { DiscordREST } from "dfx"
 import { DiscordConfig, LiveDiscordREST, Log } from "dfx"
-import { LiveDiscordGateway } from "./DiscordGateway.js"
-import { LiveJsonDiscordWSCodec } from "./DiscordGateway/DiscordWS.js"
-import { LiveMemoryShardStore } from "./DiscordGateway/ShardStore.js"
-import { LiveMemoryRateLimitStore, LiveRateLimiter } from "./RateLimit.js"
+import * as CachePrelude from "dfx/Cache/prelude"
+import type { DiscordGateway } from "dfx/DiscordGateway"
+import { LiveDiscordGateway } from "dfx/DiscordGateway"
+import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
+import { LiveJsonDiscordWSCodec } 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 * as WS from "dfx/DiscordGateway/WS"
+import type { RateLimiter } from "dfx/RateLimit"
+import { LiveMemoryRateLimitStore, LiveRateLimiter } from "dfx/RateLimit"
 
-export * as CachePrelude from "./Cache/prelude.js"
-export { DiscordGateway, LiveDiscordGateway } from "./DiscordGateway.js"
-export * as DiscordWS from "./DiscordGateway/DiscordWS.js"
-export * as Shard from "./DiscordGateway/Shard.js"
-export * as ShardStore from "./DiscordGateway/ShardStore.js"
-export * as SendEvent from "./DiscordGateway/Shard/sendEvents.js"
-export * as WS from "./DiscordGateway/WS.js"
+export { DiscordGateway, LiveDiscordGateway } from "dfx/DiscordGateway"
 export {
   InteractionsRegistry,
   InteractionsRegistryLive,
   run as runIx,
-} from "./Interactions/gateway.js"
+} from "dfx/Interactions/gateway"
+export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore, WS }
 
-export const MemoryRateLimit = LiveMemoryRateLimitStore >> LiveRateLimiter
-
-export const MemoryBot =
-  (LiveMemoryShardStore + LiveMemoryRateLimitStore + LiveJsonDiscordWSCodec) >>
-  ((LiveDiscordREST > LiveDiscordGateway) + MemoryRateLimit)
+export const MemoryRateLimit = Layer.provide(
+  LiveMemoryRateLimitStore,
+  LiveRateLimiter,
+)
 
+export const MemoryBot = Layer.provide(
+  Layer.mergeAll(
+    LiveMemoryShardStore,
+    LiveMemoryRateLimitStore,
+    LiveJsonDiscordWSCodec,
+  ),
+  Layer.merge(
+    Layer.provideMerge(LiveDiscordREST, LiveDiscordGateway),
+    MemoryRateLimit,
+  ),
+)
 export const makeLiveWithoutFetch = (
-  config: Config.Wrap<DiscordConfig.MakeOpts>,
-) =>
+  config: Config.Config.Wrap<DiscordConfig.MakeOpts>,
+): Layer.Layer<
+  HttpRequestExecutor,
+  ConfigError.ConfigError,
+  | RateLimiter
+  | Log.Log
+  | DiscordREST
+  | DiscordConfig.DiscordConfig
+  | DiscordGateway
+> =>
   Layer.unwrapEffect(
-    Config.unwrap(config)
-      .config.map(DiscordConfig.make)
-      .map(config => {
+    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 LiveLog + LiveConfig > MemoryBot
+        return Layer.provideMerge(Layer.merge(LiveLog, LiveConfig), MemoryBot)
       }),
+    ),
   )
 
-export const makeLive = (config: Config.Wrap<DiscordConfig.MakeOpts>) =>
-  LiveFetchRequestExecutor >> makeLiveWithoutFetch(config)
+export const makeLive = (
+  config: Config.Config.Wrap<DiscordConfig.MakeOpts>,
+): Layer.Layer<
+  never,
+  ConfigError.ConfigError,
+  | RateLimiter
+  | Log.Log
+  | DiscordREST
+  | DiscordConfig.DiscordConfig
+  | DiscordGateway
+> => Layer.provide(LiveFetchRequestExecutor, makeLiveWithoutFetch(config))

package/src/index.ts

@@ -1,20 +1,34 @@
-export * as Discord from "./types.js"
-export * as DiscordConfig from "./DiscordConfig.js"
-export { DiscordREST, LiveDiscordREST } from "./DiscordREST.js"
-export * as Ix from "./Interactions/index.js"
-export * as Log from "./Log.js"
+import * as Cache from "dfx/Cache"
+import * as DiscordConfig from "dfx/DiscordConfig"
+import * as Flags from "dfx/Helpers/flags"
+import * as Intents from "dfx/Helpers/intents"
+import * as IxHelpers from "dfx/Helpers/interactions"
+import * as Members from "dfx/Helpers/members"
+import * as Perms from "dfx/Helpers/permissions"
+import * as UI from "dfx/Helpers/ui"
+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 {
   BucketDetails,
-  RateLimitStore,
   LiveMemoryRateLimitStore,
-  RateLimiter,
   LiveRateLimiter,
-} from "./RateLimit.js"
-export * as Cache from "./Cache.js"
+  RateLimitStore,
+  RateLimiter,
+} from "dfx/RateLimit"
 
-export * as Flags from "./Helpers/flags.js"
-export * as Intents from "./Helpers/intents.js"
-export * as IxHelpers from "./Helpers/interactions.js"
-export * as Members from "./Helpers/members.js"
-export * as Perms from "./Helpers/permissions.js"
-export * as UI from "./Helpers/ui.js"
+export {
+  Cache,
+  Discord,
+  DiscordConfig,
+  Flags,
+  Intents,
+  Ix,
+  IxHelpers,
+  Log,
+  Members,
+  Perms,
+  UI,
+}

package/src/utils/Effect.ts

@@ -0,0 +1,69 @@
+import * as Effect from "@effect/io/Effect"
+import * as Option from "@effect/data/Option"
+import * as Ref from "@effect/io/Ref"
+import * as Queue from "@effect/io/Queue"
+import * as Hub from "@effect/io/Hub"
+import * as Deferred from "@effect/io/Deferred"
+import * as Fiber from "@effect/io/Fiber"
+
+export const subscribeForEachPar = <R, E, A, X>(
+  self: Hub.Hub<A>,
+  effect: (_: A) => Effect.Effect<R, E, X>,
+): Effect.Effect<R, E, never> =>
+  Effect.flatMap(Deferred.make<E, never>(), deferred => {
+    const run = Hub.subscribe(self).pipe(
+      Effect.flatMap(queue =>
+        Queue.take(queue).pipe(
+          Effect.flatMap(_ =>
+            effect(_).pipe(
+              Effect.catchAllCause(_ => Deferred.failCause(deferred, _)),
+              Effect.fork,
+            ),
+          ),
+          Effect.forever,
+        ),
+      ),
+      Effect.scoped,
+    )
+
+    return Effect.all(run, Deferred.await(deferred), {
+      concurrency: "unbounded",
+      discard: true,
+    }).pipe(Effect.forever)
+  })
+
+/**
+ * @tsplus fluent effect/io/Effect foreverSwitch
+ */
+export const foreverSwitch = <R, E, A, R1, E1, X>(
+  self: Effect.Effect<R, E, A>,
+  f: (_: A) => Effect.Effect<R1, E1, X>,
+): Effect.Effect<R | R1, E | E1, never> =>
+  Effect.flatMap(
+    Effect.all(
+      Deferred.make<E1, never>(),
+      Ref.make<Option.Option<Fiber.RuntimeFiber<E1, X>>>(Option.none()),
+    ),
+    ([causeDeferred, fiberRef]) => {
+      const run = Effect.flatMap(self, _ =>
+        f(_).pipe(
+          Effect.tapErrorCause(_ => Deferred.failCause(causeDeferred, _)),
+          Effect.fork,
+        ),
+      ).pipe(
+        Effect.flatMap(fiber => Ref.getAndSet(fiberRef, Option.some(fiber))),
+        Effect.tap(
+          Option.match({
+            onNone: () => Effect.unit,
+            onSome: fiber => Fiber.interrupt(fiber),
+          }),
+        ),
+        Effect.forever,
+      )
+
+      return Effect.all(run, Deferred.await(causeDeferred), {
+        concurrency: "unbounded",
+        discard: true,
+      }).pipe(Effect.forever)
+    },
+  )

package/src/version.ts

@@ -0,0 +1 @@
+export const LIB_VERSION = "0.51.2";

package/src/webhooks.ts

@@ -1,50 +1,77 @@
+import type { HttpRequestExecutor } from "@effect-http/client"
 import { LiveFetchRequestExecutor } from "@effect-http/client"
-import { LiveDiscordREST } from "./DiscordREST.js"
-import { MakeConfigOpts, makeConfigLayer } from "./Interactions/webhook.js"
-import { LiveMemoryRateLimitStore, LiveRateLimiter } from "./RateLimit.js"
+import * as Config from "@effect/io/Config"
+import type * as ConfigError from "@effect/io/Config/Error"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
 import * as DiscordConfig from "dfx/DiscordConfig"
-import * as Log from "./Log.js"
+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 * as Log from "dfx/Log"
+import type { RateLimiter } from "dfx/RateLimit"
+import { LiveMemoryRateLimitStore, LiveRateLimiter } from "dfx/RateLimit"
 
 export {
   BadWebhookSignature,
+  WebhookConfig,
+  WebhookParseError,
   makeConfigLayer,
   makeHandler,
   makeSimpleHandler,
-  WebhookConfig,
-  WebhookParseError,
-} from "./Interactions/webhook.js"
+} from "dfx/Interactions/webhook"
 
-export const MemoryRateLimit = LiveMemoryRateLimitStore >> LiveRateLimiter
+export const MemoryRateLimit = Layer.provide(
+  LiveMemoryRateLimitStore,
+  LiveRateLimiter,
+)
 
-export const MemoryREST = LiveMemoryRateLimitStore >> LiveDiscordREST
+export const MemoryREST = Layer.provide(
+  LiveMemoryRateLimitStore,
+  LiveDiscordREST,
+)
 
 export const makeLiveWithoutFetch = (
-  options: Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>,
-) =>
+  options: Config.Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>,
+): Layer.Layer<
+  HttpRequestExecutor,
+  ConfigError.ConfigError,
+  RateLimiter | DiscordREST | WebhookConfig
+> =>
   Layer.unwrapEffect(
-    Config.unwrap(options).config.map(options => {
+    Effect.map(Effect.config(Config.unwrap(options)), options => {
       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 =
-        (LiveLog + LiveConfig) >> (MemoryREST + LiveWebhook + MemoryRateLimit)
+      const LiveEnv = Layer.provide(
+        Layer.merge(LiveLog, LiveConfig),
+        Layer.mergeAll(MemoryREST, LiveWebhook, MemoryRateLimit),
+      )
+
       return LiveEnv
     }),
   )
 
 export const makeLive = (
-  config: Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>,
-) => LiveFetchRequestExecutor >> makeLiveWithoutFetch(config)
+  config: Config.Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>,
+): Layer.Layer<
+  never,
+  ConfigError.ConfigError,
+  RateLimiter | DiscordREST | WebhookConfig
+> => Layer.provide(LiveFetchRequestExecutor, makeLiveWithoutFetch(config))
 
 export const makeLiveWithoutConfig = (
   options: DiscordConfig.MakeOpts & MakeConfigOpts,
-) => {
+): Layer.Layer<never, never, 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 =
-    (LiveLog + LiveConfig) >> (MemoryREST + LiveWebhook + MemoryRateLimit)
-  return LiveFetchRequestExecutor >> LiveEnv
+  const LiveEnv = Layer.provide(
+    Layer.merge(LiveLog, LiveConfig),
+    Layer.mergeAll(MemoryREST, LiveWebhook, MemoryRateLimit),
+  )
+  return Layer.provide(LiveFetchRequestExecutor, LiveEnv)
 }

package/tsconfig.base.json

@@ -0,0 +1,48 @@
+{
+  "compilerOptions": {
+    "moduleDetection": "force",
+    "composite": true,
+    "downlevelIteration": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "preserveSymlinks": true,
+    "moduleResolution": "node",
+    "noEmit": false,
+    "lib": ["ES2021", "DOM"],
+    "sourceMap": true,
+    "declarationMap": true,
+    "strict": true,
+    "noImplicitReturns": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "noEmitOnError": false,
+    "noErrorTruncation": false,
+    "allowJs": false,
+    "checkJs": false,
+    "forceConsistentCasingInFileNames": true,
+    "stripInternal": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noUncheckedIndexedAccess": false,
+    "strictNullChecks": true,
+    "baseUrl": ".",
+    "target": "ESNext",
+    "module": "ES2022",
+    "incremental": true,
+    "removeComments": false,
+    "paths": {
+      "dfx": ["./src/index.ts"],
+      "dfx/test/*": ["./test/*"],
+      "dfx/examples/*": ["./examples/*"],
+      "dfx/*": ["./src/*"]
+    },
+    "plugins": [{ "name": "@effect/language-service" }]
+  },
+  "include": [],
+  "exclude": ["node_modules", "build", "lib"]
+}

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "build/esm",
+    "declarationDir": "build/dts",
+    "tsBuildInfoFile": "build/tsbuildinfo/esm.tsbuildinfo",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}

package/tsconfig.examples.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "build/tsbuildinfo/examples.tsbuildinfo",
+    "rootDir": "examples",
+    "module": "CommonJS",
+    "outDir": "build/examples"
+  },
+  "include": ["examples/**/*.ts"],
+  "references": [{ "path": "./tsconfig.build.json" }]
+}

package/tsconfig.json

@@ -1,10 +1,14 @@
 {
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "outDir": ".",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": []
+  "extends": "./tsconfig.base.json",
+  "references": [
+    {
+      "path": "./tsconfig.build.json"
+    },
+    {
+      "path": "./tsconfig.test.json"
+    },
+    {
+      "path": "./tsconfig.examples.json"
+    }
+  ]
 }

package/tsconfig.madge.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "baseUrl": ".",
+    "paths": {
+      "dfx": ["./build/esm/index.js"],
+      "dfx/*": ["./build/esm/*"]
+    }
+  },
+  "include": ["./build/esm/**/*"]
+}

package/tsconfig.test.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "build/tsbuildinfo/test.tsbuildinfo",
+    "rootDir": "./",
+    "noEmit": true,
+    "types": ["vitest/globals"]
+  },
+  "include": ["test/**/*", "src/**/*"]
+}