effect-slack 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mateo Kruk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,322 @@
+# effect-slack
+
+An Effect-native Slack SDK ✨
+
+## Features
+
+- **100% Type-safe** — Full TypeScript types for all 272 methods, arguments, and responses
+- **Typed errors** — Discriminated unions with `catchTag`/`catchTags` for precise error handling
+- **Observability built-in** — OpenTelemetry spans with rich attributes (method, channel, user, timestamps)
+- **Smart retries** — Rate limit aware with exponential backoff and jitter
+- **Testable by design** — Dependency injection via Effect layers, easily mockable
+- **Always up-to-date** — Auto-generated from official `@slack/web-api` types
+
+## Installation
+
+```bash
+bun add effect-slack effect
+# or
+npm install effect-slack effect
+```
+
+## Quick Start
+
+```typescript
+import { Effect } from "effect"
+import { SlackService } from "effect-slack"
+
+// Using environment variables (SLACK_TOKEN)
+const program = Effect.gen(function* () {
+  const slack = yield* SlackService
+
+  const result = yield* slack.postMessage({
+    channel: "C1234567890",
+    text: "Hello from Effect!"
+  })
+
+  console.log("Message sent:", result.ts)
+}).pipe(Effect.provide(SlackService.Live))
+
+Effect.runPromise(program)
+```
+
+## Custom Configuration
+
+```typescript
+import { Effect, Layer, Redacted } from "effect"
+import { SlackService, SlackConfig, SlackClient } from "effect-slack"
+
+const customConfig = SlackConfig.make({
+  token: Redacted.make(process.env.MY_SLACK_TOKEN!),
+  options: {
+    retryConfig: { retries: 5 }
+  }
+})
+
+const CustomSlackLayer = SlackService.Default.pipe(
+  Layer.provide(SlackClient.Default),
+  Layer.provide(customConfig)
+)
+
+const program = Effect.gen(function* () {
+  const slack = yield* SlackService
+  // ... use slack methods
+}).pipe(Effect.provide(CustomSlackLayer))
+```
+
+## Error Handling
+
+All Slack API errors are mapped to typed Effect errors that can be handled with `catchTag` or `catchTags`:
+
+```typescript
+import { Effect } from "effect"
+import { SlackService } from "effect-slack"
+
+const program = Effect.gen(function* () {
+  const slack = yield* SlackService
+  return yield* slack.postMessage({ channel: "C123", text: "Hi" })
+}).pipe(
+  Effect.catchTags({
+    SlackRateLimitedError: (e) =>
+      Effect.log(`Rate limited, retry in ${e.retryAfter}s`),
+    SlackPlatformError: (e) =>
+      e.isAuthError
+        ? Effect.logError(`Auth failed: ${e.error}`)
+        : Effect.logError(`API error: ${e.error}`),
+    SlackHttpError: (e) =>
+      Effect.logError(`HTTP ${e.statusCode}: ${e.statusMessage}`)
+  }),
+  Effect.provide(SlackService.Live)
+)
+```
+
+### Error Types
+
+| Error Type                             | Description                                                    |
+| -------------------------------------- | -------------------------------------------------------------- |
+| `SlackRequestError`                    | Network failures, DNS errors                                   |
+| `SlackHttpError`                       | Non-200 HTTP responses with `statusCode` and `body`            |
+| `SlackPlatformError`                   | Slack API errors with `error` code (e.g., `channel_not_found`) |
+| `SlackRateLimitedError`                | Rate limit exceeded, includes `retryAfter` (seconds)           |
+| `SlackFileUploadInvalidArgumentsError` | Invalid file upload arguments                                  |
+| `SlackFileUploadReadError`             | Failed to read file data                                       |
+| `SlackUnknownError`                    | Unexpected errors                                              |
+
+`SlackPlatformError` includes an `isAuthError` getter that returns `true` for auth-related errors (`invalid_auth`, `not_authed`, `token_revoked`, `token_expired`, `account_inactive`).
+
+## Retry Support
+
+The library provides two approaches to retry handling:
+
+### SDK-Level Retries (Default)
+
+The underlying `@slack/web-api` SDK handles retries automatically. You can configure it via `SlackConfig`:
+
+```typescript
+import { Redacted } from "effect"
+import { SlackConfig } from "effect-slack"
+
+const config = SlackConfig.make({
+  token: Redacted.make("xoxb-..."),
+  options: {
+    retryConfig: { retries: 5 }
+  }
+})
+```
+
+### Disabling SDK Retries
+
+To use Effect-level retries exclusively, disable SDK retries:
+
+```typescript
+import { Redacted } from "effect"
+import { SlackConfig } from "effect-slack"
+
+const config = SlackConfig.make({
+  token: Redacted.make("xoxb-..."),
+  options: {
+    retryConfig: { retries: 0 },      // Disable SDK retries
+    rejectRateLimitedCalls: true       // Don't auto-handle rate limits
+  }
+})
+```
+
+### Effect-Level Retries
+
+For more control, use the Effect-native retry utilities:
+
+```typescript
+import { Effect, pipe } from "effect"
+import {
+  SlackService,
+  withDefaultRetry,
+  withRateLimitRetry,
+  rapidRetryPolicy,
+  isRetryableError
+} from "effect-slack"
+
+// Apply default retry policy (10 retries with exponential backoff)
+const program = pipe(
+  Effect.flatMap(SlackService, (slack) =>
+    slack.postMessage({ channel: "#general", text: "Hello!" })
+  ),
+  withDefaultRetry
+)
+
+// Or use a custom schedule
+const programWithCustomRetry = pipe(
+  Effect.flatMap(SlackService, (slack) =>
+    slack.postMessage({ channel: "#general", text: "Hello!" })
+  ),
+  Effect.retry(rapidRetryPolicy)
+)
+```
+
+### Pre-built Schedules
+
+| Schedule                         | Description                                   |
+| -------------------------------- | --------------------------------------------- |
+| `tenRetriesInAboutThirtyMinutes` | 10 retries with exponential backoff + jitter  |
+| `fiveRetriesInFiveMinutes`       | 5 retries with exponential backoff + jitter   |
+| `rapidRetryPolicy`               | 3 retries with 100ms delay (for testing)      |
+| `rateLimitAwareSchedule(opts)`   | Configurable retries with exponential backoff |
+
+### Retryable Errors
+
+The `isRetryableError` function determines which errors are safe to retry:
+
+| Error Type              | Retryable | Reason                      |
+| ----------------------- | --------- | --------------------------- |
+| `SlackRateLimitedError` | Yes       | Transient, has `retryAfter` |
+| `SlackRequestError`     | Yes       | Network failures            |
+| `SlackHttpError` (5xx)  | Yes       | Server errors               |
+| `SlackHttpError` (4xx)  | No        | Client errors               |
+| `SlackPlatformError`    | Partial   | Only `service_unavailable`  |
+| Auth errors             | No        | Won't resolve with retry    |
+
+## Observability
+
+All SlackService methods are instrumented with OpenTelemetry-compatible spans.
+
+### Span Attributes
+
+| Attribute           | Description                                        |
+| ------------------- | -------------------------------------------------- |
+| `slack.method`      | Slack API method (e.g., `chat.postMessage`)        |
+| `slack.channel`     | Channel ID (where applicable)                      |
+| `slack.user`        | User ID (for user operations)                      |
+| `slack.ts`          | Message timestamp (for updates/deletes)            |
+| `slack.reaction`    | Reaction name (for reaction operations)            |
+| `error.type`        | Error tag on failures (e.g., `SlackPlatformError`) |
+| `slack.error`       | Platform error code (e.g., `channel_not_found`)    |
+| `http.status_code`  | HTTP status code on HTTP errors                    |
+| `slack.retry_after` | Retry-After seconds on rate limit errors           |
+
+### Exporting Traces
+
+Use `@effect/opentelemetry` to export traces to your observability backend:
+
+```typescript
+import { Effect } from "effect"
+import { NodeSdk } from "@effect/opentelemetry"
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base"
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http"
+import { SlackService } from "effect-slack"
+
+const TracingLive = NodeSdk.layer(() => ({
+  resource: { serviceName: "my-slack-app" },
+  spanProcessor: new BatchSpanProcessor(new OTLPTraceExporter())
+}))
+
+const program = Effect.gen(function* () {
+  const slack = yield* SlackService
+  yield* slack.postMessage({ channel: "#general", text: "Hello!" })
+})
+
+Effect.runPromise(
+  program.pipe(
+    Effect.provide(SlackService.Live),
+    Effect.provide(TracingLive)
+  )
+)
+```
+
+## Available Methods
+
+The library provides **272 methods** across **33 services**, auto-generated from the official `@slack/web-api` types. Services include:
+
+- **ChatService** - Messages, threads, scheduled messages
+- **ConversationsService** - Channels, DMs, group conversations
+- **UsersService** - User profiles, presence, identity
+- **ReactionsService** - Emoji reactions
+- **FilesService** - File uploads and management
+- **AdminService** - Workspace administration (100+ methods)
+- **AppsService**, **AuthService**, **BookmarksService**, **CallsService**, **ViewsService**, and more...
+
+Each service is available as an Effect service with full TypeScript types. See [`src/generated/`](./src/generated/) for the complete API.
+
+## Testing
+
+The library is designed to be easily testable by providing mock implementations:
+
+```typescript
+import { Effect, Layer } from "effect"
+import { SlackService, SlackClient } from "effect-slack"
+import type { WebClient } from "@slack/web-api"
+
+// Create a mock WebClient
+const mockClient = {
+  chat: {
+    postMessage: async () => ({ ok: true, ts: "1234.5678" })
+  }
+} as unknown as WebClient
+
+// Create test layer
+const TestLayer = SlackService.Default.pipe(
+  Layer.provide(SlackClient.make(mockClient))
+)
+
+// Use in tests
+const testProgram = Effect.gen(function* () {
+  const slack = yield* SlackService
+  const result = yield* slack.postMessage({
+    channel: "C123",
+    text: "Test message"
+  })
+  return result
+}).pipe(Effect.provide(TestLayer))
+```
+
+## Architecture
+
+Services are auto-generated from the `@slack/web-api` TypeScript definitions:
+
+1. **Parse** — Extract method signatures from `@slack/web-api/dist/methods.d.ts`
+2. **Generate** — Create Effect-wrapped services with typed arguments and responses
+3. **Instrument** — Add OpenTelemetry spans and error mapping to each method
+
+```
+@slack/web-api types → Parser → Code Generator → Effect Services
+```
+
+Generated services follow a consistent pattern:
+
+```typescript
+// Each method is wrapped with Effect.tryPromise, error mapping, and tracing
+const postMessage = (args: ChatPostMessageArguments): Effect.Effect<ChatPostMessageResponse, SlackError> =>
+  Effect.tryPromise({
+    try: () => client.chat.postMessage(args),
+    catch: mapSlackError
+  }).pipe(
+    Effect.tapError(annotateSpanWithError),
+    Effect.withSpan("ChatService.postMessage", {
+      attributes: { "slack.method": "chat.postMessage" }
+    })
+  )
+```
+
+Run `bun run generate` to regenerate services when updating `@slack/web-api`.
+
+## License
+
+MIT

package/dist/Errors.d.ts

@@ -0,0 +1,103 @@
+import { Schema } from "effect";
+import { ErrorCode } from "@slack/web-api";
+/**
+ * Re-export ErrorCode for consumers to use in type guards
+ */
+export { ErrorCode };
+declare const SlackRequestError_base: Schema.TaggedErrorClass<SlackRequestError, "SlackRequestError", {
+    readonly _tag: Schema.tag<"SlackRequestError">;
+} & {
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Request error - network failures, DNS errors, etc.
+ * Maps to: slack_webapi_request_error
+ */
+export declare class SlackRequestError extends SlackRequestError_base {
+}
+declare const SlackHttpError_base: Schema.TaggedErrorClass<SlackHttpError, "SlackHttpError", {
+    readonly _tag: Schema.tag<"SlackHttpError">;
+} & {
+    statusCode: typeof Schema.Number;
+    statusMessage: typeof Schema.String;
+    message: typeof Schema.String;
+    body: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * HTTP error - non-200 responses from Slack API
+ * Maps to: slack_webapi_http_error
+ */
+export declare class SlackHttpError extends SlackHttpError_base {
+}
+declare const SlackPlatformError_base: Schema.TaggedErrorClass<SlackPlatformError, "SlackPlatformError", {
+    readonly _tag: Schema.tag<"SlackPlatformError">;
+} & {
+    error: typeof Schema.String;
+    message: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * Platform error - Slack API returned an error response
+ * Maps to: slack_webapi_platform_error
+ *
+ * The `error` field contains the Slack error code (e.g., "channel_not_found", "invalid_auth")
+ */
+export declare class SlackPlatformError extends SlackPlatformError_base {
+    /**
+     * Check if this is an authentication error
+     */
+    get isAuthError(): boolean;
+}
+declare const SlackRateLimitedError_base: Schema.TaggedErrorClass<SlackRateLimitedError, "SlackRateLimitedError", {
+    readonly _tag: Schema.tag<"SlackRateLimitedError">;
+} & {
+    retryAfter: typeof Schema.Number;
+    message: typeof Schema.String;
+}>;
+/**
+ * Rate limited error - too many requests
+ * Maps to: slack_webapi_rate_limited_error
+ */
+export declare class SlackRateLimitedError extends SlackRateLimitedError_base {
+}
+declare const SlackFileUploadInvalidArgumentsError_base: Schema.TaggedErrorClass<SlackFileUploadInvalidArgumentsError, "SlackFileUploadInvalidArgumentsError", {
+    readonly _tag: Schema.tag<"SlackFileUploadInvalidArgumentsError">;
+} & {
+    message: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+}>;
+/**
+ * File upload error - invalid arguments for file upload
+ * Maps to: slack_webapi_file_upload_invalid_args_error
+ */
+export declare class SlackFileUploadInvalidArgumentsError extends SlackFileUploadInvalidArgumentsError_base {
+}
+declare const SlackFileUploadReadError_base: Schema.TaggedErrorClass<SlackFileUploadReadError, "SlackFileUploadReadError", {
+    readonly _tag: Schema.tag<"SlackFileUploadReadError">;
+} & {
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * File upload read error - failed to read file data
+ * Maps to: slack_webapi_file_upload_read_file_data_error
+ */
+export declare class SlackFileUploadReadError extends SlackFileUploadReadError_base {
+}
+declare const SlackUnknownError_base: Schema.TaggedErrorClass<SlackUnknownError, "SlackUnknownError", {
+    readonly _tag: Schema.tag<"SlackUnknownError">;
+} & {
+    message: typeof Schema.String;
+    cause: typeof Schema.Defect;
+}>;
+/**
+ * Unknown error - catch-all for unexpected errors
+ */
+export declare class SlackUnknownError extends SlackUnknownError_base {
+}
+/**
+ * Union type of all Slack errors for exhaustive handling
+ */
+export type SlackError = SlackRequestError | SlackHttpError | SlackPlatformError | SlackRateLimitedError | SlackFileUploadInvalidArgumentsError | SlackFileUploadReadError | SlackUnknownError;
+//# sourceMappingURL=Errors.d.ts.map

package/dist/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../src/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C;;GAEG;AACH,OAAO,EAAE,SAAS,EAAE,CAAA;;;;;;;AAEpB;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,sBAMtC;CAAG;;;;;;;;;AAEJ;;;GAGG;AACH,qBAAa,cAAe,SAAQ,mBAKlC;CAAG;;;;;;;;AAEL;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,uBAOvC;IACC;;OAEG;IACH,IAAI,WAAW,IAAI,OAAO,CAQzB;CACF;;;;;;;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,0BAM1C;CAAG;;;;;;;AAEJ;;;GAGG;AACH,qBAAa,oCAAqC,SAAQ,yCAMzD;CAAG;;;;;;;AAEJ;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,6BAM7C;CAAG;;;;;;;AAEJ;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,sBAMtC;CAAG;AAEJ;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,iBAAiB,GACjB,cAAc,GACd,kBAAkB,GAClB,qBAAqB,GACrB,oCAAoC,GACpC,wBAAwB,GACxB,iBAAiB,CAAA"}

package/dist/Errors.js

@@ -0,0 +1,84 @@
+import { Schema } from "effect";
+import { ErrorCode } from "@slack/web-api";
+/**
+ * Re-export ErrorCode for consumers to use in type guards
+ */
+export { ErrorCode };
+/**
+ * Request error - network failures, DNS errors, etc.
+ * Maps to: slack_webapi_request_error
+ */
+export class SlackRequestError extends Schema.TaggedError()("SlackRequestError", {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect)
+}) {
+}
+/**
+ * HTTP error - non-200 responses from Slack API
+ * Maps to: slack_webapi_http_error
+ */
+export class SlackHttpError extends Schema.TaggedError()("SlackHttpError", {
+    statusCode: Schema.Number,
+    statusMessage: Schema.String,
+    message: Schema.String,
+    body: Schema.optional(Schema.Unknown)
+}) {
+}
+/**
+ * Platform error - Slack API returned an error response
+ * Maps to: slack_webapi_platform_error
+ *
+ * The `error` field contains the Slack error code (e.g., "channel_not_found", "invalid_auth")
+ */
+export class SlackPlatformError extends Schema.TaggedError()("SlackPlatformError", {
+    error: Schema.String,
+    message: Schema.String,
+    data: Schema.optional(Schema.Unknown)
+}) {
+    /**
+     * Check if this is an authentication error
+     */
+    get isAuthError() {
+        return (this.error === "invalid_auth" ||
+            this.error === "not_authed" ||
+            this.error === "token_revoked" ||
+            this.error === "token_expired" ||
+            this.error === "account_inactive");
+    }
+}
+/**
+ * Rate limited error - too many requests
+ * Maps to: slack_webapi_rate_limited_error
+ */
+export class SlackRateLimitedError extends Schema.TaggedError()("SlackRateLimitedError", {
+    retryAfter: Schema.Number,
+    message: Schema.String
+}) {
+}
+/**
+ * File upload error - invalid arguments for file upload
+ * Maps to: slack_webapi_file_upload_invalid_args_error
+ */
+export class SlackFileUploadInvalidArgumentsError extends Schema.TaggedError()("SlackFileUploadInvalidArgumentsError", {
+    message: Schema.String,
+    data: Schema.optional(Schema.Unknown)
+}) {
+}
+/**
+ * File upload read error - failed to read file data
+ * Maps to: slack_webapi_file_upload_read_file_data_error
+ */
+export class SlackFileUploadReadError extends Schema.TaggedError()("SlackFileUploadReadError", {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect)
+}) {
+}
+/**
+ * Unknown error - catch-all for unexpected errors
+ */
+export class SlackUnknownError extends Schema.TaggedError()("SlackUnknownError", {
+    message: Schema.String,
+    cause: Schema.Defect
+}) {
+}
+//# sourceMappingURL=Errors.js.map

package/dist/Errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.js","sourceRoot":"","sources":["../src/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C;;GAEG;AACH,OAAO,EAAE,SAAS,EAAE,CAAA;AAEpB;;;GAGG;AACH,MAAM,OAAO,iBAAkB,SAAQ,MAAM,CAAC,WAAW,EAAqB,CAC5E,mBAAmB,EACnB;IACE,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;CACtC,CACF;CAAG;AAEJ;;;GAGG;AACH,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC,WAAW,EAAkB,CAAC,gBAAgB,EAAE;IACzF,UAAU,EAAE,MAAM,CAAC,MAAM;IACzB,aAAa,EAAE,MAAM,CAAC,MAAM;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;CACtC,CAAC;CAAG;AAEL;;;;;GAKG;AACH,MAAM,OAAO,kBAAmB,SAAQ,MAAM,CAAC,WAAW,EAAsB,CAC9E,oBAAoB,EACpB;IACE,KAAK,EAAE,MAAM,CAAC,MAAM;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;CACtC,CACF;IACC;;OAEG;IACH,IAAI,WAAW;QACb,OAAO,CACL,IAAI,CAAC,KAAK,KAAK,cAAc;YAC7B,IAAI,CAAC,KAAK,KAAK,YAAY;YAC3B,IAAI,CAAC,KAAK,KAAK,eAAe;YAC9B,IAAI,CAAC,KAAK,KAAK,eAAe;YAC9B,IAAI,CAAC,KAAK,KAAK,kBAAkB,CAClC,CAAA;IACH,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,qBAAsB,SAAQ,MAAM,CAAC,WAAW,EAAyB,CACpF,uBAAuB,EACvB;IACE,UAAU,EAAE,MAAM,CAAC,MAAM;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM;CACvB,CACF;CAAG;AAEJ;;;GAGG;AACH,MAAM,OAAO,oCAAqC,SAAQ,MAAM,CAAC,WAAW,EAAwC,CAClH,sCAAsC,EACtC;IACE,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;CACtC,CACF;CAAG;AAEJ;;;GAGG;AACH,MAAM,OAAO,wBAAyB,SAAQ,MAAM,CAAC,WAAW,EAA4B,CAC1F,0BAA0B,EAC1B;IACE,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;CACtC,CACF;CAAG;AAEJ;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,MAAM,CAAC,WAAW,EAAqB,CAC5E,mBAAmB,EACnB;IACE,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,KAAK,EAAE,MAAM,CAAC,MAAM;CACrB,CACF;CAAG"}

package/dist/Retry.d.ts

@@ -0,0 +1,63 @@
+import { Duration, Effect, Schedule } from "effect";
+import type { SlackError } from "./Errors.js";
+/**
+ * Options for creating retry schedules
+ */
+export interface RetryOptions {
+    readonly maxRetries?: number;
+    readonly baseDelay?: Duration.DurationInput;
+}
+/**
+ * Check if an error is transient and safe to retry
+ */
+export declare const isRetryableError: (error: SlackError) => boolean;
+/**
+ * Effect equivalent of SDK's tenRetriesInAboutThirtyMinutes
+ * 10 retries with exponential backoff + jitter
+ */
+export declare const tenRetriesInAboutThirtyMinutes: Schedule.Schedule<number, SlackError>;
+/**
+ * Effect equivalent of SDK's fiveRetriesInFiveMinutes
+ * 5 retries with exponential backoff + jitter
+ */
+export declare const fiveRetriesInFiveMinutes: Schedule.Schedule<number, SlackError>;
+/**
+ * Rapid retry policy for testing
+ * 3 retries with 100ms fixed delay
+ */
+export declare const rapidRetryPolicy: Schedule.Schedule<number, SlackError>;
+/**
+ * Schedule that respects Slack's Retry-After header for rate limits
+ * Uses exponential backoff for non-rate-limit errors
+ */
+export declare const rateLimitAwareSchedule: (options?: RetryOptions) => Schedule.Schedule<number, SlackError>;
+/**
+ * Retry an effect with the default policy (tenRetriesInAboutThirtyMinutes)
+ */
+export declare const withDefaultRetry: <A, E extends SlackError, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Retry an effect with rate-limit awareness
+ * Automatically uses retryAfter from SlackRateLimitedError
+ */
+export declare const withRateLimitRetry: <A, E extends SlackError, R>(effect: Effect.Effect<A, E, R>, options?: RetryOptions) => Effect.Effect<A, E, R>;
+/**
+ * Retry only rate limit errors with exact retryAfter timing
+ * Does NOT retry other error types
+ */
+export declare const withRateLimitOnlyRetry: <A, E extends SlackError, R>(effect: Effect.Effect<A, E, R>, options?: {
+    maxRetries?: number;
+}) => Effect.Effect<A, E, R>;
+/**
+ * Retry with fallback - returns a fallback value if all retries fail
+ */
+export declare const withRetryOrElse: <A, B, E extends SlackError, R, R2>(effect: Effect.Effect<A, E, R>, fallback: (error: E, fiberId: unknown) => Effect.Effect<B, E, R2>, schedule?: Schedule.Schedule<unknown, E>) => Effect.Effect<A | B, E, R | R2>;
+/**
+ * All pre-built schedules as a namespace
+ */
+export declare const Schedules: {
+    readonly tenRetriesInAboutThirtyMinutes: Schedule.Schedule<number, SlackError, never>;
+    readonly fiveRetriesInFiveMinutes: Schedule.Schedule<number, SlackError, never>;
+    readonly rapidRetryPolicy: Schedule.Schedule<number, SlackError, never>;
+    readonly rateLimitAwareSchedule: (options?: RetryOptions) => Schedule.Schedule<number, SlackError>;
+};
+//# sourceMappingURL=Retry.d.ts.map

package/dist/Retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retry.d.ts","sourceRoot":"","sources":["../src/Retry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAQ,QAAQ,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAA;CAC5C;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,UAAU,KAAG,OAgBpD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAMhF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAM1E,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAKlE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAU,YAAY,KACrB,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAWtC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,SAAS,UAAU,EAAE,CAAC,EACzD,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAC8D,CAAA;AAEtF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,SAAS,UAAU,EAAE,CAAC,EAC3D,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC9B,UAAU,YAAY,KACrB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAC+D,CAAA;AAEvF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,EAAE,CAAC,SAAS,UAAU,EAAE,CAAC,EAC/D,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC9B,UAAU;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,KAChC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAIpB,CAAA;AAEJ;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,UAAU,EAAE,CAAC,EAAE,EAAE,EAC/D,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC9B,UAAU,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EACjE,WAAW,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,KACvC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAK9B,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;gDA9DV,YAAY,KACrB,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAkE9B,CAAA"}

package/dist/Retry.js

@@ -0,0 +1,77 @@
+import { Duration, Effect, pipe, Schedule } from "effect";
+/**
+ * Check if an error is transient and safe to retry
+ */
+export const isRetryableError = (error) => {
+    switch (error._tag) {
+        case "SlackRateLimitedError":
+            return true;
+        case "SlackRequestError":
+            return true;
+        case "SlackHttpError":
+            return error.statusCode >= 500;
+        case "SlackPlatformError":
+            if (error.isAuthError)
+                return false;
+            return error.error === "service_unavailable" || error.error === "internal_error";
+        case "SlackFileUploadInvalidArgumentsError":
+        case "SlackFileUploadReadError":
+        case "SlackUnknownError":
+            return false;
+    }
+};
+/**
+ * Effect equivalent of SDK's tenRetriesInAboutThirtyMinutes
+ * 10 retries with exponential backoff + jitter
+ */
+export const tenRetriesInAboutThirtyMinutes = pipe(Schedule.exponential("1 second", 2), Schedule.jittered, Schedule.intersect(Schedule.recurs(10)), Schedule.whileInput(isRetryableError), Schedule.map(([, count]) => count));
+/**
+ * Effect equivalent of SDK's fiveRetriesInFiveMinutes
+ * 5 retries with exponential backoff + jitter
+ */
+export const fiveRetriesInFiveMinutes = pipe(Schedule.exponential("1 second", 2), Schedule.jittered, Schedule.intersect(Schedule.recurs(5)), Schedule.whileInput(isRetryableError), Schedule.map(([, count]) => count));
+/**
+ * Rapid retry policy for testing
+ * 3 retries with 100ms fixed delay
+ */
+export const rapidRetryPolicy = pipe(Schedule.fixed("100 millis"), Schedule.intersect(Schedule.recurs(3)), Schedule.whileInput(isRetryableError), Schedule.map(([, count]) => count));
+/**
+ * Schedule that respects Slack's Retry-After header for rate limits
+ * Uses exponential backoff for non-rate-limit errors
+ */
+export const rateLimitAwareSchedule = (options) => {
+    const maxRetries = options?.maxRetries ?? 10;
+    const baseDelay = options?.baseDelay ?? "1 second";
+    return pipe(Schedule.exponential(baseDelay, 2), Schedule.jittered, Schedule.intersect(Schedule.recurs(maxRetries)), Schedule.whileInput(isRetryableError), Schedule.map(([, count]) => count));
+};
+/**
+ * Retry an effect with the default policy (tenRetriesInAboutThirtyMinutes)
+ */
+export const withDefaultRetry = (effect) => Effect.retry(effect, tenRetriesInAboutThirtyMinutes);
+/**
+ * Retry an effect with rate-limit awareness
+ * Automatically uses retryAfter from SlackRateLimitedError
+ */
+export const withRateLimitRetry = (effect, options) => Effect.retry(effect, rateLimitAwareSchedule(options));
+/**
+ * Retry only rate limit errors with exact retryAfter timing
+ * Does NOT retry other error types
+ */
+export const withRateLimitOnlyRetry = (effect, options) => Effect.retry(effect, {
+    while: (error) => error._tag === "SlackRateLimitedError",
+    times: options?.maxRetries ?? 5
+});
+/**
+ * Retry with fallback - returns a fallback value if all retries fail
+ */
+export const withRetryOrElse = (effect, fallback, schedule) => Effect.retryOrElse(effect, schedule ?? tenRetriesInAboutThirtyMinutes, fallback);
+/**
+ * All pre-built schedules as a namespace
+ */
+export const Schedules = {
+    tenRetriesInAboutThirtyMinutes,
+    fiveRetriesInFiveMinutes,
+    rapidRetryPolicy,
+    rateLimitAwareSchedule
+};
+//# sourceMappingURL=Retry.js.map