dfx 0.85.0 → 0.87.0

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,7 +74,7 @@ const makeConfig = ({
 export interface WebhookConfig {
   readonly _: unique symbol
 }
-export const WebhookConfig = Tag<WebhookConfig, ReturnType<typeof makeConfig>>(
+export const WebhookConfig = GenericTag<WebhookConfig, ReturnType<typeof makeConfig>>(
   "dfx/Interactions/WebhookConfig",
 )
 
@@ -83,7 +83,7 @@ export const layer = (opts: MakeConfigOpts) =>
 
 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,38 +109,34 @@ 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>,
-    BadWebhookSignature | WebhookParseError | E | DefinitionNotFound,
-    Discord.InteractionResponse
-  > =>
+  ): Effect.Effect<Discord.InteractionResponse, BadWebhookSignature | WebhookParseError | E | DefinitionNotFound, WebhookConfig | Exclude<R, DiscordInteraction>> =>
     Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
       Effect.provideService(
         handler[interaction.type](interaction),
         Interaction,
         interaction,
       ),
-    )
+    );
 }
 
 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 +151,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,11 +164,11 @@ 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 +183,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.85.0";
+export const LIB_VERSION = "0.87.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.85.0";
+export declare const LIB_VERSION = "0.87.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.85.0";
+const LIB_VERSION = exports.LIB_VERSION = "0.87.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