@effect-uai/slack 0.16.0 → 0.18.0

package/src/Slack.ts

@@ -3,7 +3,6 @@ import {
   type Cause,
   Context,
   Effect,
-  Encoding,
   Layer,
   Match,
   Option,
@@ -12,7 +11,9 @@ import {
   type Scope,
   Stream,
 } from "effect"
-import { HttpClient } from "effect/unstable/http"
+import { Base64 } from "effect/encoding"
+import { HttpClient } from "effect/http"
+import * as Socket from "effect/socket/Socket"
 import type { MediaSource } from "@effect-uai/core/Media"
 import {
   CurrentConversation,
@@ -225,7 +226,10 @@ export const make = (
       ),
     )
 
-    const session = yield* SocketMode.connect({ open })
+    // The ticket is in the URL, so every runtime's global `WebSocket` is enough.
+    const session = yield* SocketMode.connect({ open }).pipe(
+      Effect.provide(Socket.layerWebSocketConstructorGlobal),
+    )
     const toEvents = Events.toEvents({ bot, replyIn: cfg.replyIn ?? "thread" })
     const inbox = yield* Queue.unbounded<InboundEvent, MessengerError.MessengerError | Cause.Done>()
 
@@ -298,7 +302,7 @@ export const make = (
         Match.tag("url", ({ url }) => sendUrl(at, msg, body, url)),
         Match.tag("bytes", ({ bytes, mimeType }) => sendBytes(at, msg, body, bytes, mimeType)),
         Match.tag("base64", ({ base64, mimeType }) =>
-          Effect.fromResult(Encoding.decodeBase64(base64)).pipe(
+          Effect.fromResult(Base64.decode(base64)).pipe(
             Effect.mapError(invalidMedia),
             Effect.flatMap((bytes) => sendBytes(at, msg, body, bytes, mimeType)),
           ),

package/src/internal/api.ts

@@ -1,10 +1,5 @@
 import { Data, Duration, Effect, Option, Redacted, Schema } from "effect"
-import {
-  Headers,
-  HttpClient,
-  HttpClientRequest,
-  type HttpClientResponse,
-} from "effect/unstable/http"
+import { Headers, HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/http"
 import * as MessengerError from "@effect-uai/core/MessengerError"
 
 export const provider = "slack"

package/src/internal/socket.test.ts

@@ -1,6 +1,32 @@
-import { Option } from "effect"
+import { it as effect } from "@effect/vitest"
+import { Effect, Exit, Layer, Option, Queue, Ref } from "effect"
+import * as Socket from "effect/socket/Socket"
 import { describe, expect, it } from "vitest"
-import { classifyDisconnect, remember } from "./socket.js"
+import * as MessengerError from "@effect-uai/core/MessengerError"
+import * as FakeWebSocket from "@effect-uai/core/testing/FakeWebSocket"
+import { classifyDisconnect, connect, remember } from "./socket.js"
+
+const command = (envelopeId: string) => ({
+  type: "slash_commands",
+  envelope_id: envelopeId,
+  payload: { channel_id: "C1", user_id: "U1", command: "/ping" },
+})
+
+/** Each connection dials its own single-use URL, so each gets its own fake server. */
+const slack = (connections: number) =>
+  Effect.gen(function* () {
+    const servers = yield* Effect.forEach(Array.from({ length: connections }), () =>
+      FakeWebSocket.make({ greeting: [{ type: "hello" }] }),
+    )
+    const opened = yield* Ref.make(0)
+    const open = Ref.modify(opened, (n): [string, number] => [`wss://slack.test/${n}`, n + 1])
+    const dial: Socket.WebSocketConstructor["Service"] = (url, protocols) =>
+      servers[Number(url.split("/").pop())]!.connect(url, protocols)
+    const session = yield* connect({ open }).pipe(
+      Effect.provide(Layer.succeed(Socket.WebSocketConstructor, dial)),
+    )
+    return { servers, opened: Ref.get(opened), session }
+  })
 
 describe("classifyDisconnect", () => {
   it("ends only on the reason Slack says not to retry", () => {
@@ -23,3 +49,82 @@ describe("remember", () => {
     expect(Option.getOrThrow(remember(full, "c", 2))).toEqual(["b", "c"])
   })
 })
+
+describe("connect", () => {
+  effect.live("acknowledges an envelope before handing it on", () =>
+    Effect.gen(function* () {
+      const { servers, session } = yield* slack(1)
+      yield* servers[0]!.push(command("e1"))
+
+      const incoming = yield* Queue.take(session.envelopes)
+      expect(incoming.envelope.envelope_id).toBe("e1")
+      yield* servers[0]!.awaitSent(1)
+      expect(yield* servers[0]!.sent).toEqual([{ envelope_id: "e1" }])
+    }).pipe(Effect.scoped),
+  )
+
+  effect.live("fails to connect when no URL can be had before hello", () =>
+    Effect.gen(function* () {
+      const exit = yield* connect({
+        open: Effect.fail(
+          new MessengerError.MessengerConnectFailed({
+            provider: "slack",
+            reason: "invalid_auth",
+            raw: undefined,
+          }),
+        ),
+      }).pipe(Effect.provide(Socket.layerWebSocketConstructorGlobal), Effect.exit)
+
+      expect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain("invalid_auth")
+    }).pipe(Effect.scoped),
+  )
+
+  // Clean or dirty, a close Slack did not announce is a drop, and every drop reconnects.
+  for (const code of [1000, 1006]) {
+    effect.live(`reconnects on a fresh URL after a ${code} close`, () =>
+      Effect.gen(function* () {
+        const { servers, opened, session } = yield* slack(2)
+        yield* servers[0]!.close(code)
+        yield* servers[1]!.greeted
+        yield* servers[1]!.push(command("e2"))
+
+        const incoming = yield* Queue.take(session.envelopes)
+        expect(incoming.envelope.envelope_id).toBe("e2")
+        expect(yield* opened).toBe(2)
+        yield* servers[1]!.awaitSent(1)
+        expect(yield* servers[1]!.sent).toEqual([{ envelope_id: "e2" }])
+      }).pipe(Effect.scoped),
+    )
+  }
+
+  effect.live("closes and reconnects on a refresh disconnect", () =>
+    Effect.gen(function* () {
+      const { servers, opened, session } = yield* slack(2)
+      yield* servers[0]!.push({ type: "disconnect", reason: "refresh_requested" })
+      yield* servers[1]!.greeted
+      yield* servers[1]!.push(command("e3"))
+
+      const incoming = yield* Queue.take(session.envelopes)
+      expect(incoming.envelope.envelope_id).toBe("e3")
+      expect(yield* opened).toBe(2)
+    }).pipe(Effect.scoped),
+  )
+
+  effect.live("ends envelopes on a disconnect Slack says not to retry", () =>
+    Effect.gen(function* () {
+      const { servers, opened, session } = yield* slack(1)
+      yield* servers[0]!.push({ type: "disconnect", reason: "link_disabled" })
+
+      const exit = yield* Effect.exit(Queue.take(session.envelopes))
+      expect(exit).toEqual(
+        Exit.fail(
+          new MessengerError.MessengerTransportClosed({
+            provider: "slack",
+            reason: "link_disabled",
+          }),
+        ),
+      )
+      expect(yield* opened).toBe(1)
+    }).pipe(Effect.scoped),
+  )
+})

package/src/internal/socket.ts

@@ -10,9 +10,11 @@ import {
   Ref,
   Schema,
   type Scope,
+  Stream,
 } from "effect"
-import * as Socket from "effect/unstable/socket/Socket"
+import * as Socket from "effect/socket/Socket"
 import * as MessengerError from "@effect-uai/core/MessengerError"
+import { isCleanClose } from "@effect-uai/core/WebSocketSession"
 import * as Events from "./events.js"
 import { provider } from "./api.js"
 
@@ -108,7 +110,11 @@ const backoff = (attempt: number): Duration.Duration =>
  */
 export const connect = (
   cfg: Config,
-): Effect.Effect<Session, MessengerError.MessengerConnectFailed, Scope.Scope> =>
+): Effect.Effect<
+  Session,
+  MessengerError.MessengerConnectFailed,
+  Scope.Scope | Socket.WebSocketConstructor
+> =>
   Effect.gen(function* () {
     const envelopes = yield* Queue.unbounded<Incoming, MessengerError.MessengerError | Cause.Done>()
     const ready = yield* Deferred.make<void, MessengerError.MessengerConnectFailed>()
@@ -119,20 +125,19 @@ export const connect = (
 
     const once = Effect.gen(function* () {
       const url = yield* cfg.open
-      const socket = yield* Socket.makeWebSocket(url, {
-        // Effect treats every close as an error by default; the standard clean
-        // codes are not, and Slack's close codes say nothing a reconnect
-        // cannot fix, so a `disconnect` frame is the only fatal signal.
-        closeCodeIsError: (code: number) => code !== 1000 && code !== 1001 && code !== 1005,
-        // The ticket is in the URL, so every runtime's global `WebSocket` is enough.
-      }).pipe(Effect.provide(Socket.layerWebSocketConstructorGlobal))
-      const write = yield* socket.writer
+      const socket = yield* Socket.makeWebSocket(url)
+      const { write } = yield* socket.writer
+      // The writer waits for a reconnect that never comes on this URL, so
+      // nothing is written once this connection's reader has ended.
+      const closed = yield* Ref.make(false)
+      const send = (chunk: string | Socket.CloseEvent) =>
+        Effect.flatMap(Ref.get(closed), (isClosed) => (isClosed ? Effect.void : write(chunk)))
       // Set by a `disconnect` frame, the one end a close code cannot express.
       const requested = yield* Ref.make(Option.none<Ended>())
 
       // Acknowledged before the envelope is offered, well inside Slack's three
       // second deadline, so the platform is never waiting on the recipe.
-      const acknowledge = (envelopeId: string) => write(JSON.stringify({ envelope_id: envelopeId }))
+      const acknowledge = (envelopeId: string) => send(JSON.stringify({ envelope_id: envelopeId }))
 
       // A redelivery is acknowledged like any other envelope and then dropped,
       // so Slack stops retrying it and the recipe never sees it twice.
@@ -152,7 +157,7 @@ export const connect = (
         Effect.gen(function* () {
           const action = classifyDisconnect(reason)
           yield* Ref.set(requested, Option.some<Ended>({ action, reason: reason ?? "disconnect" }))
-          yield* write(new Socket.CloseEvent(1000, reason ?? "disconnect"))
+          yield* send(new Socket.CloseEvent(1000, reason ?? "disconnect"))
         })
 
       const handle = (text: string) =>
@@ -170,9 +175,13 @@ export const connect = (
           )
         }).pipe(Effect.ignore)
 
-      // A clean 1000 is only ever our own teardown or a disconnect we asked
+      // A clean close is only ever our own teardown or a disconnect we asked
       // for; anything else is a drop, and every drop reconnects.
-      const ended = yield* socket.runString(handle).pipe(
+      const ended = yield* Stream.fromPull(Socket.readerString(socket)).pipe(
+        Stream.scoped,
+        Stream.catchIf(isCleanClose, () => Stream.empty),
+        Stream.runForEach(handle),
+        Effect.ensuring(Ref.set(closed, true)),
         Effect.as<Ended>({ action: "reconnect", reason: "closed" }),
         Effect.catch((error: Socket.SocketError) =>
           Effect.succeed<Ended>({ action: "reconnect", reason: reasonOf(error) }),