dfx 1.0.5 → 1.0.6

package/dist/src/Interactions/webhook.ts

@@ -1,204 +0,0 @@
-import * as Chunk from "effect/Chunk"
-import { identity } from "effect/Function"
-import * as Option from "effect/Option"
-import type * as Cause from "effect/Cause"
-import type * as Config from "effect/Config"
-import * as Redacted from "effect/Redacted"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as ServiceMap from "effect/ServiceMap"
-import type * as D from "./definitions.ts"
-import type { DefinitionNotFound } from "./handlers.ts"
-import { handlers } from "./handlers.ts"
-import type { DiscordInteraction, InteractionBuilder } from "./index.ts"
-import { Interaction } from "./index.ts"
-import type * as Discord from "../types.ts"
-import * as Verify from "discord-verify"
-import * as Data from "effect/Data"
-
-export class BadWebhookSignature {
-  readonly _tag = "BadWebhookSignature"
-}
-
-export type Headers = Record<string, string | Array<string> | undefined>
-
-const checkSignature = (
-  publicKey: string,
-  headers: Headers,
-  body: string,
-  crypto: SubtleCrypto,
-  algorithm: any,
-) =>
-  Effect.fromOption(
-    Option.all({
-      signature: Option.fromNullishOr(headers["x-signature-ed25519"]),
-      timestamp: Option.fromNullishOr(headers["x-signature-timestamp"]),
-    }),
-  ).pipe(
-    Effect.flatMap(_ =>
-      Effect.promise(() =>
-        Verify.verify(
-          body,
-          _.signature as string,
-          _.timestamp as string,
-          publicKey,
-          crypto,
-          algorithm,
-        ),
-      ),
-    ),
-    Effect.filterOrFail(identity, () => new BadWebhookSignature()),
-    Effect.catchCause(() => Effect.fail(new BadWebhookSignature())),
-    Effect.asVoid,
-  )
-
-export interface MakeConfigOpts {
-  readonly applicationId: string
-  readonly publicKey: Redacted.Redacted
-  readonly crypto: SubtleCrypto
-  readonly algorithm: keyof typeof Verify.PlatformAlgorithm
-}
-const makeConfig = ({
-  algorithm,
-  applicationId,
-  crypto,
-  publicKey,
-}: MakeConfigOpts) => ({
-  applicationId,
-  publicKey: Redacted.value(publicKey),
-  crypto,
-  algorithm: Verify.PlatformAlgorithm[algorithm],
-})
-
-export class WebhookConfig extends ServiceMap.Service<
-  WebhookConfig,
-  ReturnType<typeof makeConfig>
->()("dfx/Interactions/WebhookConfig") {}
-
-export const layer = (opts: MakeConfigOpts) =>
-  Layer.succeed(WebhookConfig, makeConfig(opts))
-
-export const layerConfig: (
-  config: Config.Config<MakeConfigOpts>,
-) => Layer.Layer<WebhookConfig, Config.ConfigError> = (
-  config: Config.Config<MakeConfigOpts>,
-) => Layer.effect(WebhookConfig, Effect.map(config.asEffect(), makeConfig))
-
-export class WebhookParseError extends Data.TaggedError("WebhookParseError")<{
-  cause: unknown
-}> {}
-
-const fromHeadersAndBody = (headers: Headers, body: string) =>
-  WebhookConfig.use(({ algorithm, crypto, publicKey }) =>
-    checkSignature(publicKey, headers, body, crypto, algorithm).pipe(
-      Effect.andThen(
-        Effect.try({
-          try: () => JSON.parse(body) as Discord.APIInteraction,
-          catch: cause => new WebhookParseError({ cause }),
-        }),
-      ),
-    ),
-  )
-
-const run = <R, E>(
-  definitions: Chunk.Chunk<
-    readonly [
-      handler: D.InteractionDefinition<R, E>,
-      transform: (
-        self: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
-      ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
-    ]
-  >,
-  handleResponse: (
-    ix: Discord.APIInteraction,
-    _: Discord.CreateInteractionResponseRequest,
-  ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
-) => {
-  const handler = handlers(definitions, handleResponse)
-  return (
-    headers: Headers,
-    body: string,
-  ): Effect.Effect<
-    Discord.CreateInteractionResponseRequest,
-    BadWebhookSignature | WebhookParseError | E | DefinitionNotFound,
-    WebhookConfig | Exclude<R, DiscordInteraction>
-  > =>
-    Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
-      Effect.withSpan(
-        Effect.provideService(
-          handler[interaction.type](interaction),
-          Interaction,
-          interaction,
-        ),
-        "dfx.Interaction",
-        {
-          attributes: { interactionId: interaction.id },
-          captureStackTrace: false,
-        },
-      ),
-    )
-}
-
-export interface HandleWebhookOpts<E> {
-  headers: Headers
-  body: string
-  success: (a: Discord.CreateInteractionResponseRequest) => Effect.Effect<void>
-  error: (e: Cause.Cause<E>) => Effect.Effect<void>
-}
-
-/**
- * @tsplus getter dfx/InteractionBuilder webhookHandler
- */
-export const makeHandler = <R, E, TE>(
-  ix: InteractionBuilder<R, E, TE>,
-): (({
-  body,
-  error,
-  headers,
-  success,
-}: HandleWebhookOpts<
-  E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
->) => Effect.Effect<void, never, WebhookConfig>) => {
-  const handle = run(
-    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
-    (_i, r) => Effect.succeed(r),
-  )
-
-  return ({
-    body,
-    error,
-    headers,
-    success,
-  }: HandleWebhookOpts<
-    E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
-  >): Effect.Effect<void, never, WebhookConfig> =>
-    handle(headers, body).pipe(
-      Effect.flatMap(success),
-      Effect.catchCause(error),
-    )
-}
-
-/**
- * @tsplus getter dfx/InteractionBuilder simpleWebhookHandler
- */
-export const makeSimpleHandler = <R, E, TE>(
-  ix: InteractionBuilder<R, E, TE>,
-): (({
-  body,
-  headers,
-}: {
-  headers: Headers
-  body: string
-}) => Effect.Effect<
-  Discord.CreateInteractionResponseRequest,
-  BadWebhookSignature | WebhookParseError | DefinitionNotFound,
-  WebhookConfig
->) => {
-  const handle = run(
-    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
-    (_i, r) => Effect.succeed(r),
-  )
-
-  return ({ body, headers }: { headers: Headers; body: string }) =>
-    handle(headers, body)
-}

package/dist/src/RateLimit/memory.ts

@@ -1,63 +0,0 @@
-import * as Option from "effect/Option"
-import * as Effect from "effect/Effect"
-import type { BucketDetails, RateLimitStoreService } from "../RateLimit.ts"
-
-interface Counter {
-  count: number
-  expires: number
-}
-
-export const make = (): RateLimitStoreService => {
-  const buckets = new Map<string, BucketDetails>()
-  const routes = new Map<string, string>()
-  const counters = new Map<string, Counter>()
-
-  const getCounter = (key: string) =>
-    Option.filter(
-      Option.fromNullishOr(counters.get(key)),
-      c => c.expires > Date.now(),
-    )
-
-  const getBucketForRoute = (route: string) =>
-    Effect.sync(() => Option.fromNullishOr(buckets.get(routes.get(route)!)))
-
-  return {
-    hasBucket: key => Effect.sync(() => buckets.has(key)),
-
-    putBucket: bucket =>
-      Effect.sync(() => {
-        buckets.set(bucket.key, bucket)
-      }),
-
-    getBucketForRoute,
-
-    putBucketRoute: (route, bucket) =>
-      Effect.sync(() => {
-        routes.set(route, bucket)
-      }),
-
-    removeCounter: key =>
-      Effect.sync(() => {
-        counters.delete(key)
-      }),
-
-    incrementCounter: (key, window, limit) =>
-      Effect.sync(() => {
-        const now = Date.now()
-        const perRequest = Math.ceil(window / limit)
-        const counter = Option.getOrElse(
-          getCounter(key),
-          (): Counter => ({
-            expires: now,
-            count: 0,
-          }),
-        )
-
-        const count = counter.count + 1
-        const expires = counter.expires + perRequest
-        counters.set(key, { ...counter, count, expires })
-
-        return [count, expires - now]
-      }),
-  }
-}

package/dist/src/RateLimit/utils.ts

@@ -1,28 +0,0 @@
-import type { Duration } from "effect/Duration"
-import { millis, zero } from "effect/Duration"
-
-export const delayFrom = (
-  window: number,
-  limit: number,
-  count: number,
-  ttl: number,
-): Duration => {
-  const perRequest = Math.ceil(window / limit)
-
-  const totalTime = count * perRequest
-  const elapsedTime = totalTime - ttl
-  const elapsedWindows = Math.floor(elapsedTime / window)
-  const completedRequests = elapsedWindows * limit
-  const remainingRequests = count - completedRequests
-  const remainingWindows = Math.floor((remainingRequests - 1) / limit)
-  const delayRemainder = elapsedTime % window
-
-  const requestRemainder = count % limit
-  const staggerDelay = requestRemainder * 50
-
-  if (remainingWindows === 0) {
-    return zero
-  }
-
-  return millis(remainingWindows * window - delayRemainder + staggerDelay)
-}

package/dist/src/RateLimit.ts

@@ -1,90 +0,0 @@
-import * as Duration from "effect/Duration"
-import type * as Option from "effect/Option"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Memory from "./RateLimit/memory.ts"
-import { delayFrom } from "./RateLimit/utils.ts"
-import * as ServiceMap from "effect/ServiceMap"
-
-export type BucketDetails = {
-  key: "global" | string
-  resetAfter: number
-  limit: number
-}
-
-export interface RateLimitStoreService {
-  readonly hasBucket: (bucketKey: string) => Effect.Effect<boolean>
-
-  readonly putBucket: (bucket: BucketDetails) => Effect.Effect<void>
-
-  readonly getBucketForRoute: (
-    route: string,
-  ) => Effect.Effect<Option.Option<BucketDetails>>
-
-  readonly putBucketRoute: (
-    route: string,
-    bucketKey: string,
-  ) => Effect.Effect<void>
-
-  readonly incrementCounter: (
-    key: string,
-    window: number,
-    limit: number,
-  ) => Effect.Effect<readonly [count: number, ttl: number]>
-
-  readonly removeCounter: (key: string) => Effect.Effect<void>
-}
-
-export class RateLimitStore extends ServiceMap.Service<
-  RateLimitStore,
-  RateLimitStoreService
->()("dfx/RateLimit/RateLimitStore") {}
-
-export const MemoryRateLimitStoreLive = Layer.sync(RateLimitStore, Memory.make)
-
-const makeLimiter = Effect.gen(function* () {
-  const store = yield* RateLimitStore
-
-  const maybeWait = (
-    key: string,
-    window: Duration.Duration,
-    limit: number,
-    multiplier = 1.05,
-  ) => {
-    const windowMs = Duration.toMillis(window) * multiplier
-
-    return store.incrementCounter(key, windowMs, limit).pipe(
-      Effect.map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl)),
-      Effect.tap(d =>
-        Effect.annotateLogs(Effect.logTrace("maybeWait"), {
-          service: "RateLimit",
-          key,
-          window: Duration.toMillis(window),
-          windowMs,
-          limit,
-          delay: Duration.toMillis(d),
-        }),
-      ),
-      Effect.tap(_ =>
-        Duration.toMillis(_) === 0 ? Effect.void : Effect.sleep(_),
-      ),
-      Effect.asVoid,
-    )
-  }
-
-  return { maybeWait }
-})
-
-export class RateLimiter extends ServiceMap.Service<
-  RateLimiter,
-  {
-    maybeWait: (
-      key: string,
-      window: Duration.Duration,
-      limit: number,
-      multiplier?: number,
-    ) => Effect.Effect<void, never, never>
-  }
->()("dfx/RateLimit/RateLimiter") {}
-
-export const RateLimiterLive = Layer.effect(RateLimiter, makeLimiter)

package/dist/src/gateway.ts

@@ -1,50 +0,0 @@
-import * as CachePrelude from "./Cache/prelude.ts"
-import type { DiscordGateway } from "./DiscordGateway.ts"
-import { DiscordGatewayLive } from "./DiscordGateway.ts"
-import * as DiscordWS from "./DiscordGateway/DiscordWS.ts"
-import { JsonDiscordWSCodecLive } from "./DiscordGateway/DiscordWS.ts"
-import * as Shard from "./DiscordGateway/Shard.ts"
-import { ShardStateStore } from "./DiscordGateway/Shard/StateStore.ts"
-import * as SendEvent from "./DiscordGateway/Shard/sendEvents.ts"
-import * as ShardStore from "./DiscordGateway/ShardStore.ts"
-import { MemoryShardStoreLive } from "./DiscordGateway/ShardStore.ts"
-import type { DiscordREST } from "./DiscordREST.ts"
-import { DiscordRESTLive } from "./DiscordREST.ts"
-import type { InteractionsRegistry } from "./Interactions/gateway.ts"
-import { InteractionsRegistryLive } from "./Interactions/gateway.ts"
-import type { RateLimiter } from "./RateLimit.ts"
-import { MemoryRateLimitStoreLive, RateLimiterLive } from "./RateLimit.ts"
-import * as Layer from "effect/Layer"
-import type * as HttpClient from "effect/unstable/http/HttpClient"
-import type { DiscordConfig } from "./DiscordConfig.ts"
-import type { WebSocketConstructor } from "effect/unstable/socket/Socket"
-
-export { DiscordGateway, DiscordGatewayLive } from "./DiscordGateway.ts"
-
-export {
-  InteractionsRegistry,
-  InteractionsRegistryLive,
-  interactionsSync,
-  run as runIx,
-  setInteractionsSync,
-} from "./Interactions/gateway.ts"
-
-export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore }
-
-export const DiscordLive: Layer.Layer<
-  RateLimiter | DiscordGateway | DiscordREST,
-  never,
-  DiscordConfig | WebSocketConstructor | HttpClient.HttpClient
-> = Layer.mergeAll(RateLimiterLive, DiscordGatewayLive).pipe(
-  Layer.provideMerge(DiscordRESTLive),
-  Layer.provide(JsonDiscordWSCodecLive),
-  Layer.provide(MemoryRateLimitStoreLive),
-  Layer.provide(MemoryShardStoreLive),
-  Layer.provide(ShardStateStore.MemoryLive),
-)
-
-export const DiscordIxLive: Layer.Layer<
-  RateLimiter | DiscordGateway | DiscordREST | InteractionsRegistry,
-  never,
-  DiscordConfig | WebSocketConstructor | HttpClient.HttpClient
-> = InteractionsRegistryLive.pipe(Layer.provideMerge(DiscordLive))

package/dist/src/index.ts

@@ -1,44 +0,0 @@
-import type { HttpClient } from "effect/unstable/http/HttpClient"
-import * as Cache from "./Cache.ts"
-import * as DiscordConfig from "./DiscordConfig.ts"
-import type { DiscordREST } from "./DiscordREST.ts"
-import { DiscordRESTLive } from "./DiscordREST.ts"
-import * as Flags from "./Helpers/flags.ts"
-import * as Intents from "./Helpers/intents.ts"
-import * as IxHelpers from "./Helpers/interactions.ts"
-import * as Members from "./Helpers/members.ts"
-import * as Perms from "./Helpers/permissions.ts"
-import * as UI from "./Helpers/ui.ts"
-import * as Ix from "./Interactions/index.ts"
-import { MemoryRateLimitStoreLive } from "./RateLimit.ts"
-import * as Discord from "./types.ts"
-import * as Layer from "effect/Layer"
-
-export { DiscordREST, DiscordRESTLive } from "./DiscordREST.ts"
-
-export {
-  type BucketDetails,
-  MemoryRateLimitStoreLive,
-  RateLimitStore,
-  RateLimiter,
-  RateLimiterLive,
-} from "./RateLimit.ts"
-
-export {
-  Cache,
-  Discord,
-  DiscordConfig,
-  Flags,
-  Intents,
-  Ix,
-  IxHelpers,
-  Members,
-  Perms,
-  UI,
-}
-
-export const DiscordRESTMemoryLive: Layer.Layer<
-  DiscordREST,
-  never,
-  DiscordConfig.DiscordConfig | HttpClient
-> = DiscordRESTLive.pipe(Layer.provide(MemoryRateLimitStoreLive))