dfx 0.86.0 → 0.88.0

package/src/Interactions/definitions.ts

@@ -65,13 +65,13 @@ export const guild = <
 export class MessageComponent<R, E> {
   readonly _tag = "MessageComponent"
   constructor(
-    readonly predicate: (customId: string) => Effect.Effect<R, E, boolean>,
-    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
+    readonly predicate: (customId: string) => Effect.Effect<boolean, E, R>,
+    readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
 export const messageComponent = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<R1, E1, boolean>,
+  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
   handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
 ) =>
   new MessageComponent<
@@ -82,14 +82,14 @@ export const messageComponent = <R1, R2, E1, E2>(
 export class ModalSubmit<R, E> {
   readonly _tag = "ModalSubmit"
   constructor(
-    readonly predicate: (customId: string) => Effect.Effect<R, E, boolean>,
-    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
+    readonly predicate: (customId: string) => Effect.Effect<boolean, E, R>,
+    readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
 export const modalSubmit = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<R1, E1, boolean>,
-  handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
+  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
+  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
 ) =>
   new ModalSubmit<
     Exclude<R1 | R2, DiscordInteraction | DiscordModalSubmit>,
@@ -102,8 +102,8 @@ export class Autocomplete<R, E> {
     readonly predicate: (
       data: Discord.ApplicationCommandDatum,
       focusedOption: Discord.ApplicationCommandInteractionDataOption,
-    ) => Effect.Effect<R, E, boolean>,
-    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
+    ) => Effect.Effect<boolean, E, R>,
+    readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
@@ -111,8 +111,8 @@ export const autocomplete = <R1, R2, E1, E2>(
   pred: (
     data: Discord.ApplicationCommandDatum,
     focusedOption: Discord.ApplicationCommandInteractionDataOption,
-  ) => Effect.Effect<R1, E1, boolean>,
-  handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
+  ) => Effect.Effect<boolean, E1, R1>,
+  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
 ) =>
   new Autocomplete<
     Exclude<
@@ -123,45 +123,46 @@ export const autocomplete = <R1, R2, E1, E2>(
   >(pred as any, handle as any)
 
 // ==== Command handler helpers
-type DeepReadonly<T> = T extends Array<infer R>
-  ? ReadonlyArray<DeepReadonly<R>>
-  : T extends Function
-    ? T
-    : T extends object
-      ? DeepReadonlyObject<T>
-      : T
+type DeepReadonly<T> =
+  T extends Array<infer R>
+    ? ReadonlyArray<DeepReadonly<R>>
+    : T extends Function
+      ? T
+      : T extends object
+        ? DeepReadonlyObject<T>
+        : T
 type DeepReadonlyObject<T> = {
   readonly [P in keyof T]: DeepReadonly<T[P]>
 }
 
 export type CommandHandler<R, E, A = any> =
-  | Effect.Effect<R, E, Discord.InteractionResponse>
+  | Effect.Effect<Discord.InteractionResponse, E, R>
   | CommandHandlerFn<R, E, A>
 
 export interface CommandHelper<A> {
   resolve: <T>(
     name: AllResolvables<A>["name"],
     f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) => Effect.Effect<DiscordInteraction, ResolvedDataNotFound, T>
+  ) => Effect.Effect<T, ResolvedDataNotFound, DiscordInteraction>
 
   option: (
     name: AllCommandOptions<A>["name"],
   ) => Effect.Effect<
-    DiscordApplicationCommand,
+    Option.Option<Discord.ApplicationCommandInteractionDataOption>,
     never,
-    Option.Option<Discord.ApplicationCommandInteractionDataOption>
+    DiscordApplicationCommand
   >
 
   optionValue: <N extends AllRequiredCommandOptions<A>["name"]>(
     name: N,
-  ) => Effect.Effect<DiscordApplicationCommand, never, CommandValue<A, N>>
+  ) => Effect.Effect<CommandValue<A, N>, never, DiscordApplicationCommand>
 
   optionValueOptional: <N extends AllCommandOptions<A>["name"]>(
     name: N,
   ) => Effect.Effect<
-    DiscordApplicationCommand,
+    Option.Option<CommandValue<A, N>>,
     never,
-    Option.Option<CommandValue<A, N>>
+    DiscordApplicationCommand
   >
 
   subCommands: <
@@ -169,11 +170,17 @@ export interface CommandHelper<A> {
       ? never
       : Record<
           SubCommandNames<A>,
-          Effect.Effect<any, any, Discord.InteractionResponse>
+          Effect.Effect<Discord.InteractionResponse, any, any>
         >,
   >(
     commands: NER,
   ) => Effect.Effect<
+    Discord.InteractionResponse,
+    [NER[keyof NER]] extends [
+      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+    ]
+      ? E
+      : never,
     | Exclude<
         [NER[keyof NER]] extends [
           { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
@@ -183,19 +190,13 @@ export interface CommandHelper<A> {
         SubCommandContext
       >
     | DiscordInteraction
-    | DiscordApplicationCommand,
-    [NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-    ]
-      ? E
-      : never,
-    Discord.InteractionResponse
+    | DiscordApplicationCommand
   >
 }
 
 export type CommandHandlerFn<R, E, A> = (
   i: CommandHelper<A>,
-) => Effect.Effect<R, E, Discord.InteractionResponse>
+) => Effect.Effect<Discord.InteractionResponse, E, R>
 
 interface CommandOption {
   readonly type: any

package/src/Interactions/gateway.ts

@@ -1,5 +1,5 @@
 import * as Chunk from "effect/Chunk"
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import { pipe } from "effect/Function"
 import * as Effect from "effect/Effect"
@@ -38,18 +38,18 @@ export const run =
   <R, R2, E, TE, E2>(
     postHandler: (
       effect: Effect.Effect<
-        R | DiscordREST | DiscordInteraction,
+        void,
         TE | DiscordRESTError | DefinitionNotFound,
-        void
+        R | DiscordREST | DiscordInteraction
       >,
-    ) => Effect.Effect<R2, E2, void>,
+    ) => Effect.Effect<void, E2, R2>,
   ) =>
   (
     ix: InteractionBuilder<R, E, TE>,
   ): Effect.Effect<
-    DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>,
+    never,
     E2 | DiscordRESTError | Http.error.ResponseError,
-    never
+    DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>
   > =>
     Effect.gen(function* (_) {
       const GlobalApplicationCommand = ix.definitions.pipe(
@@ -73,8 +73,7 @@ export const run =
       const rest = yield* _(DiscordREST)
 
       const application = yield* _(
-        rest.getCurrentBotApplicationInformation(),
-        Effect.flatMap(a => a.json),
+        rest.getCurrentBotApplicationInformation().json,
       )
 
       const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
@@ -84,20 +83,22 @@ export const run =
             GlobalApplicationCommand.map(_ => _.command),
           ),
         },
-      )
+      ).asUnit
 
       const guildSync = GuildApplicationCommand.length
-        ? gateway.handleDispatch("GUILD_CREATE", a =>
-            rest.bulkOverwriteGuildApplicationCommands(
-              application.id,
-              a.id,
-              GuildApplicationCommand.map(_ => _.command) as any,
-            ),
+        ? gateway.handleDispatch(
+            "GUILD_CREATE",
+            a =>
+              rest.bulkOverwriteGuildApplicationCommands(
+                application.id,
+                a.id,
+                GuildApplicationCommand.map(_ => _.command) as any,
+              ).asUnit,
           )
         : Effect.never
 
       const handle = handlers(ix.definitions, (i, r) =>
-        rest.createInteractionResponse(i.id, i.token, r),
+        rest.createInteractionResponse(i.id, i.token, r).pipe(Effect.scoped),
       )
 
       const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
@@ -160,13 +161,13 @@ const makeRegistry = Effect.gen(function* (_) {
 export interface InteractionsRegistryService {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 }
 export interface InteractionsRegistry {
   readonly _: unique symbol
 }
 
-export const InteractionsRegistry = Tag<
+export const InteractionsRegistry = GenericTag<
   InteractionsRegistry,
   InteractionsRegistryService
 >("dfx/Interactions/InteractionsRegistry")

package/src/Interactions/handlers.ts

@@ -13,22 +13,22 @@ export class DefinitionNotFound {
 }
 
 type Handler<R, E, A> = Effect.Effect<
-  R | Ctx.DiscordInteraction,
+  A,
   E | DefinitionNotFound,
-  A
+  R | Ctx.DiscordInteraction
 >
 
 export const handlers = <R, E, TE, A, B>(
   definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
+      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect.Effect<R, E, A>,
+  ) => Effect.Effect<A, E, R>,
 ): Record<
   Discord.InteractionType,
   (i: Discord.Interaction) => Handler<R, E, B>

package/src/Interactions/utils.ts

@@ -4,16 +4,14 @@ import * as Ctx from "dfx/Interactions/context"
 import type * as D from "dfx/Interactions/definitions"
 import type * as Discord from "dfx/types"
 
-export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
-  R,
-  E
-> extends infer D
-  ? {
-      [K in keyof D]: K extends "handle"
-        ? (_: Discord.Interaction) => Effect.Effect<R, TE, A>
-        : D[K]
-    }
-  : never
+export type DefinitionFlattened<R, E, TE, A> =
+  D.InteractionDefinition<R, E> extends infer D
+    ? {
+        [K in keyof D]: K extends "handle"
+          ? (_: Discord.Interaction) => Effect.Effect<A, TE, R>
+          : D[K]
+      }
+    : never
 
 export type DefinitionFlattenedCommand<R, E, TE, A> = Extract<
   DefinitionFlattened<R, E, TE, A>,
@@ -32,13 +30,13 @@ export const flattenDefinitions = <R, E, TE, A, B>(
   definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
+      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect.Effect<R, E, A>,
+  ) => Effect.Effect<A, E, R>,
 ) =>
   Chunk.map(definitions, ([definition, transform]) => ({
     ...definition,

package/src/Interactions/webhook.ts

@@ -1,5 +1,5 @@
 import * as Chunk from "effect/Chunk"
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import { identity } from "effect/Function"
 import * as Option from "effect/Option"
 import type * as Cause from "effect/Cause"
@@ -74,16 +74,17 @@ const makeConfig = ({
 export interface WebhookConfig {
   readonly _: unique symbol
 }
-export const WebhookConfig = Tag<WebhookConfig, ReturnType<typeof makeConfig>>(
-  "dfx/Interactions/WebhookConfig",
-)
+export const WebhookConfig = GenericTag<
+  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<never, ConfigError.ConfigError, WebhookConfig> = (
+) => Layer.Layer<WebhookConfig, ConfigError.ConfigError> = (
   config: Config.Config<MakeConfigOpts>,
 ) => Layer.effect(WebhookConfig, Effect.map(config, makeConfig))
 
@@ -109,23 +110,23 @@ const run = <R, E>(
     readonly [
       handler: D.InteractionDefinition<R, E>,
       transform: (
-        self: Effect.Effect<R, E, Discord.InteractionResponse>,
-      ) => Effect.Effect<R, E, Discord.InteractionResponse>,
+        self: Effect.Effect<Discord.InteractionResponse, E, R>,
+      ) => Effect.Effect<Discord.InteractionResponse, E, R>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect.Effect<R, E, Discord.InteractionResponse>,
+  ) => Effect.Effect<Discord.InteractionResponse, E, R>,
 ) => {
   const handler = handlers(definitions, handleResponse)
   return (
     headers: Headers,
     body: string,
   ): Effect.Effect<
-    WebhookConfig | Exclude<R, DiscordInteraction>,
+    Discord.InteractionResponse,
     BadWebhookSignature | WebhookParseError | E | DefinitionNotFound,
-    Discord.InteractionResponse
+    WebhookConfig | Exclude<R, DiscordInteraction>
   > =>
     Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
       Effect.provideService(
@@ -139,8 +140,8 @@ const run = <R, E>(
 export interface HandleWebhookOpts<E> {
   headers: Headers
   body: string
-  success: (a: Discord.InteractionResponse) => Effect.Effect<never, never, void>
-  error: (e: Cause.Cause<E>) => Effect.Effect<never, never, void>
+  success: (a: Discord.InteractionResponse) => Effect.Effect<void>
+  error: (e: Cause.Cause<E>) => Effect.Effect<void>
 }
 
 /**
@@ -155,7 +156,7 @@ export const makeHandler = <R, E, TE>(
   success,
 }: HandleWebhookOpts<
   E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
->) => Effect.Effect<WebhookConfig, never, void>) => {
+>) => Effect.Effect<void, never, WebhookConfig>) => {
   const handle = run(
     Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
     (_i, r) => Effect.succeed(r),
@@ -168,7 +169,7 @@ export const makeHandler = <R, E, TE>(
     success,
   }: HandleWebhookOpts<
     E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
-  >): Effect.Effect<WebhookConfig, never, void> =>
+  >): Effect.Effect<void, never, WebhookConfig> =>
     handle(headers, body).pipe(
       Effect.flatMap(success),
       Effect.catchAllCause(error),
@@ -187,9 +188,9 @@ export const makeSimpleHandler = <R, E, TE>(
   headers: Headers
   body: string
 }) => Effect.Effect<
-  WebhookConfig,
+  Discord.InteractionResponse,
   BadWebhookSignature | WebhookParseError | DefinitionNotFound,
-  Discord.InteractionResponse
+  WebhookConfig
 >) => {
   const handle = run(
     Chunk.map(ix.definitions, ([d]) => [d, identity] as any),

package/src/RateLimit.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import type * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
@@ -15,35 +15,35 @@ export type BucketDetails = {
 export interface RateLimitStoreService {
   readonly hasBucket: (
     bucketKey: string,
-  ) => Effect.Effect<never, never, boolean>
+  ) => Effect.Effect<boolean>
 
   readonly putBucket: (
     bucket: BucketDetails,
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 
   readonly getBucketForRoute: (
     route: string,
-  ) => Effect.Effect<never, never, Option.Option<BucketDetails>>
+  ) => Effect.Effect<Option.Option<BucketDetails>>
 
   readonly putBucketRoute: (
     route: string,
     bucketKey: string,
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 
   readonly incrementCounter: (
     key: string,
     window: number,
     limit: number,
-  ) => Effect.Effect<never, never, readonly [count: number, ttl: number]>
+  ) => Effect.Effect<readonly [count: number, ttl: number]>
 
-  readonly removeCounter: (key: string) => Effect.Effect<never, never, void>
+  readonly removeCounter: (key: string) => Effect.Effect<void>
 }
 
 export interface RateLimitStore {
   readonly _: unique symbol
 }
 
-export const RateLimitStore = Tag<RateLimitStore, RateLimitStoreService>(
+export const RateLimitStore = GenericTag<RateLimitStore, RateLimitStoreService>(
   "dfx/RateLimit/RateLimitStore",
 )
 export const MemoryRateLimitStoreLive = Layer.sync(RateLimitStore, Memory.make)
@@ -84,7 +84,7 @@ const makeLimiter = Effect.gen(function* (_) {
 export interface RateLimiter {
   readonly _: unique symbol
 }
-export const RateLimiter = Tag<
+export const RateLimiter = GenericTag<
   RateLimiter,
   Effect.Effect.Success<typeof makeLimiter>
 >("dfx/RateLimit/RateLimiter")

package/src/utils/Effect.ts

@@ -7,9 +7,9 @@ import * as Queue from "effect/Queue"
 
 export const subscribeForEachPar = <R, E, A, X>(
   self: PubSub.PubSub<A>,
-  effect: (_: A) => Effect.Effect<R, E, X>,
-): Effect.Effect<R, E, never> =>
-  Effect.flatMap(Deferred.make<E, never>(), deferred => {
+  effect: (_: A) => Effect.Effect<X, E, R>,
+): Effect.Effect<never, E, R> =>
+  Effect.flatMap(Deferred.make<never, E>(), deferred => {
     const run = pipe(
       PubSub.subscribe(self),
       Effect.flatMap(queue =>
@@ -29,15 +29,15 @@ export const subscribeForEachPar = <R, E, A, X>(
     return Effect.all([run, Deferred.await(deferred)], {
       concurrency: "unbounded",
       discard: true,
-    }) as Effect.Effect<R, E, never>
+    }) as Effect.Effect<never, E, R>
   })
 
 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> =>
+  self: Effect.Effect<A, E, R>,
+  f: (_: A) => Effect.Effect<X, E1, R1>,
+): Effect.Effect<never, E | E1, R | R1> =>
   pipe(
-    Effect.all([Deferred.make<E1, never>(), Effect.fiberId]),
+    Effect.all([Deferred.make<never, E1>(), Effect.fiberId]),
     Effect.flatMap(([causeDeferred, fiberId]) => {
       let fiber: Fiber.RuntimeFiber<unknown, unknown> | undefined
 
@@ -64,6 +64,6 @@ export const foreverSwitch = <R, E, A, R1, E1, X>(
       return Effect.all([run, Deferred.await(causeDeferred)], {
         concurrency: "unbounded",
         discard: true,
-      }) as Effect.Effect<R | R1, E | E1, never>
+      }) as Effect.Effect<never, E | E1, R | R1>
     }),
   )

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.86.0";
+export const LIB_VERSION = "0.88.0";

package/utils/Effect.d.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
 import * as PubSub from "effect/PubSub";
-export declare const subscribeForEachPar: <R, E, A, X>(self: PubSub.PubSub<A>, effect: (_: A) => Effect.Effect<R, E, X>) => Effect.Effect<R, E, never>;
-export declare 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>;
+export declare const subscribeForEachPar: <R, E, A, X>(self: PubSub.PubSub<A>, effect: (_: A) => Effect.Effect<X, E, R>) => Effect.Effect<never, E, R>;
+export declare const foreverSwitch: <R, E, A, R1, E1, X>(self: Effect.Effect<A, E, R>, f: (_: A) => Effect.Effect<X, E1, R1>) => Effect.Effect<never, E | E1, R | R1>;
 //# sourceMappingURL=Effect.d.ts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LIB_VERSION = "0.86.0";
+export declare const LIB_VERSION = "0.88.0";
 //# 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.86.0";
+const LIB_VERSION = exports.LIB_VERSION = "0.88.0";
 //# sourceMappingURL=version.js.map

package/webhooks.d.ts

@@ -1,4 +1,4 @@
 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, import("dfx/RateLimit").RateLimiter | import("dfx/DiscordREST").DiscordREST>;
+export declare const DiscordLive: Layer.Layer<import("dfx/RateLimit").RateLimiter | import("dfx/DiscordREST").DiscordREST, never, import("./DiscordConfig").DiscordConfig>;
 //# sourceMappingURL=webhooks.d.ts.map