@effect/platform-bun 4.0.2 → 4.0.3

package/src/BunDns.ts

@@ -0,0 +1,82 @@
+/**
+ * Bun implementation of Effect's `Dns` service.
+ *
+ * Address lookups use `Bun.dns.lookup` with the `system` backend, which calls
+ * the operating system resolver (`getaddrinfo`) and therefore also reads the
+ * hosts file. Bun's `node:dns` lookup uses c-ares instead, which bypasses the
+ * system's name service configuration. Record queries and reverse lookups use
+ * `NodeDns.resolver` without the UTF-8 correction of `NodeDns.make`,
+ * because Bun already decodes TXT and CAA character strings as UTF-8.
+ *
+ * **Gotchas**
+ *
+ * Bun returns each character string of a TXT record as a separate record, so
+ * a record made of several strings arrives as several TXT records whose chunks
+ * cannot be reassembled (https://github.com/oven-sh/bun/issues/44692).
+ *
+ * Bun's resolver cannot query TLSA records, so TLSA queries fail with
+ * `Unsupported`.
+ *
+ * @stability experimental
+ * @since 4.0.0
+ */
+import * as NodeDns from "@effect/platform-node-shared/NodeDns"
+import * as Config from "effect/Config"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Dns from "effect/net/Dns"
+import type * as NetAddress from "effect/net/NetAddress"
+
+export type {
+  /**
+   * Options for the Bun `Dns` service: name servers, timeout, and tries for
+   * record queries and reverse lookups.
+   *
+   * @stability experimental
+   * @category re-exports
+   * @since 4.0.0
+   */
+  Options
+} from "@effect/platform-node-shared/NodeDns"
+
+/**
+ * Creates a Bun `Dns` service whose resolver lives as long as the scope.
+ *
+ * @stability experimental
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = Effect.fnUntraced(function*(options?: NodeDns.Options) {
+  const resolve = yield* NodeDns.resolver(options)
+  return Dns.make({
+    lookup: (host, family) =>
+      Effect.tryPromise({
+        try: () => Bun.dns.lookup(host, { family: NodeDns.toFamily(family), backend: "system" }),
+        catch: (cause) => NodeDns.dnsErrorFromCause(cause, "lookup", host)
+      }).pipe(Effect.map(NodeDns.addressesFromLookup)),
+    resolve
+  })
+})
+
+/**
+ * Layer that provides the Bun `Dns` service using the system resolver
+ * configuration.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export const layer: Layer.Layer<Dns.Dns> = Layer.effect(Dns.Dns, Effect.orDie(make()))
+
+/**
+ * Creates a layer that provides the Bun `Dns` service with options read
+ * from configuration.
+ *
+ * @stability experimental
+ * @category layers
+ * @since 4.0.0
+ */
+export const layerConfig = (
+  options: Config.Wrap<NodeDns.Options>
+): Layer.Layer<Dns.Dns, Config.ConfigError | NetAddress.NetAddressError> =>
+  Layer.effect(Dns.Dns, Effect.flatMap(Config.unwrap(options), make))

package/src/BunSocket.ts

@@ -22,7 +22,8 @@ export * from "@effect/platform-node-shared/NodeSocket"
 
 /**
  * Provides a `Socket.WebSocketConstructor` backed by Bun's global
- * `WebSocket` implementation.
+ * `WebSocket` implementation, supporting handshake headers and subprotocols
+ * together in client options objects.
  *
  * @stability unstable
  * @category layers
@@ -31,15 +32,32 @@ export * from "@effect/platform-node-shared/NodeSocket"
 export const layerWebSocketConstructor: Layer.Layer<
   Socket.WebSocketConstructor
 > = Layer.succeed(Socket.WebSocketConstructor)(
-  (url, options) =>
-    // Bun accepts `WebSocketOptions`, but `bun-types` selects the DOM overload
-    // when `lib.dom` is loaded and hides those constructor options.
-    new globalThis.WebSocket(url, options as string | Array<string> | undefined)
+  (url, options) => {
+    if (options === undefined || typeof options === "string" || Array.isArray(options)) {
+      return new globalThis.WebSocket(url, options)
+    }
+    // Bun accepts `WebSocketOptions`, but `bun-types` selects the DOM
+    // overload when `lib.dom` is loaded and hides those constructor options.
+    const WebSocket = globalThis.WebSocket as unknown as {
+      new(
+        url: string,
+        options: {
+          protocols?: Array<string> | undefined
+          headers?: Readonly<Record<string, string>> | undefined
+        }
+      ): globalThis.WebSocket
+    }
+    return new WebSocket(url, {
+      // Bun requires a sequence for `protocols` in its options object.
+      protocols: typeof options.protocols === "string" ? [options.protocols] : options.protocols,
+      headers: options.headers
+    })
+  }
 )
 
 /**
  * Creates a `Socket.Socket` layer for a WebSocket URL using Bun's global
- * `WebSocket` constructor, honoring protocol, open-timeout, and
+ * `WebSocket` constructor, honoring protocol, handshake-header, open-timeout, and
  * high-water-mark options.
  *
  * @stability unstable
@@ -51,6 +69,7 @@ export const layerWebSocket: (
   options?: {
     readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
     readonly highWaterMark?: number | undefined
   } | undefined
 ) => Layer.Layer<Socket.Socket, never, never> = flow(

package/src/BunTerminal.ts

@@ -15,8 +15,9 @@ import type { Scope } from "effect/Scope"
 import type { Terminal, UserInput } from "effect/Terminal"
 
 /**
- * Creates a scoped `Terminal` service backed by process stdin/stdout, using the
- * optional predicate to decide when key input should end the input stream.
+ * Creates a scoped `Terminal` service backed by process stdin/stdout.
+ * By default, Esc, Ctrl+C, and Ctrl+D end key input. Supply `shouldQuit` to
+ * override these quit keys.
  *
  * @stability unstable
  * @category constructors
@@ -26,7 +27,7 @@ export const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Termin
 
 /**
  * Provides the default process-backed `Terminal` service, ending key input on
- * the default quit keys.
+ * bare Esc, Ctrl+C, or Ctrl+D.
  *
  * @stability unstable
  * @category layers

package/src/BunWorkerRunner.ts

@@ -64,7 +64,6 @@ export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succe
               trackFiber(fiber)
             }
           } else {
-            port.close()
             Deferred.doneUnsafe(closeLatch, Exit.void)
           }
         }

package/src/index.ts

@@ -5,6 +5,12 @@
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as BunAddressResolver from "./BunAddressResolver.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0
@@ -29,6 +35,18 @@ export * as BunClusterSocket from "./BunClusterSocket.ts"
  */
 export * as BunCrypto from "./BunCrypto.ts"
 
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as BunDatagramSocket from "./BunDatagramSocket.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as BunDns from "./BunDns.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0