@effect/platform-bun 0.87.0 → 4.0.0-beta.0

package/src/BunPath.ts

@@ -1,25 +1,24 @@
 /**
  * @since 1.0.0
  */
-
 import * as NodePath from "@effect/platform-node-shared/NodePath"
-import type { Path } from "@effect/platform/Path"
-import type { Layer } from "effect/Layer"
+import type * as Layer from "effect/Layer"
+import type { Path } from "effect/Path"
 
 /**
  * @since 1.0.0
  * @category layer
  */
-export const layer: Layer<Path> = NodePath.layer
+export const layer: Layer.Layer<Path> = NodePath.layer
 
 /**
  * @since 1.0.0
  * @category layer
  */
-export const layerPosix: Layer<Path> = NodePath.layerPosix
+export const layerPosix: Layer.Layer<Path> = NodePath.layerPosix
 
 /**
  * @since 1.0.0
  * @category layer
  */
-export const layerWin32: Layer<Path> = NodePath.layerWin32
+export const layerWin32: Layer.Layer<Path> = NodePath.layerWin32

package/src/BunRedis.ts

@@ -0,0 +1,74 @@
+/**
+ * @since 1.0.0
+ */
+import { RedisClient, type RedisOptions } from "bun"
+import * as Config from "effect/Config"
+import * as Effect from "effect/Effect"
+import * as Fn from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import * as ServiceMap from "effect/ServiceMap"
+import * as Redis from "effect/unstable/persistence/Redis"
+
+/**
+ * @since 1.0.0
+ * @category Service
+ */
+export class BunRedis extends ServiceMap.Service<BunRedis, {
+  readonly client: RedisClient
+  readonly use: <A>(f: (client: RedisClient) => Promise<A>) => Effect.Effect<A, Redis.RedisError>
+}>()("@effect/platform-bun/BunRedis") {}
+
+const make = Effect.fnUntraced(function*(
+  options?: {
+    readonly url?: string
+  } & RedisOptions
+) {
+  const scope = yield* Effect.scope
+  yield* Scope.addFinalizer(scope, Effect.sync(() => client.close()))
+  const client = new RedisClient(options?.url, options)
+
+  const use = <A>(f: (client: RedisClient) => Promise<A>) =>
+    Effect.tryPromise({
+      try: () => f(client),
+      catch: (cause) => new Redis.RedisError({ cause })
+    })
+
+  const redis = yield* Redis.make({
+    send: <A = unknown>(command: string, ...args: ReadonlyArray<string>) =>
+      Effect.tryPromise({
+        try: () => client.send(command, args as Array<string>) as Promise<A>,
+        catch: (cause) => new Redis.RedisError({ cause })
+      })
+  })
+
+  const bunRedis = Fn.identity<BunRedis["Service"]>({
+    client,
+    use
+  })
+
+  return ServiceMap.make(BunRedis, bunRedis).pipe(
+    ServiceMap.add(Redis.Redis, redis)
+  )
+})
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layer = (
+  options?: ({ readonly url?: string } & RedisOptions) | undefined
+): Layer.Layer<Redis.Redis | BunRedis> => Layer.effectServices(make(options))
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerConfig = (
+  options: Config.Wrap<{ readonly url?: string } & RedisOptions>
+): Layer.Layer<Redis.Redis | BunRedis, Config.ConfigError> =>
+  Layer.effectServices(
+    Config.unwrap(options).asEffect().pipe(
+      Effect.flatMap(make)
+    )
+  )

package/src/BunRuntime.ts

@@ -2,10 +2,102 @@
  * @since 1.0.0
  */
 import * as NodeRuntime from "@effect/platform-node-shared/NodeRuntime"
-import type { RunMain } from "@effect/platform/Runtime"
+import type { Effect } from "effect/Effect"
+import type { Teardown } from "effect/Runtime"
 
 /**
+ * Helps you run a main effect with built-in error handling, logging, and signal management.
+ *
+ * **Details**
+ *
+ * This function launches an Effect as the main entry point, setting exit codes
+ * based on success or failure, handling interrupts (e.g., Ctrl+C), and optionally
+ * logging errors. By default, it logs errors and uses a "pretty" format, but both
+ * behaviors can be turned off. You can also provide custom teardown logic to
+ * finalize resources or produce different exit codes.
+ *
+ * **Options**
+ *
+ * An optional object that can include:
+ * - `disableErrorReporting`: Turn off automatic error logging.
+ * - `disablePrettyLogger`: Avoid adding the pretty logger.
+ * - `teardown`: Provide custom finalization logic.
+ *
+ * **When to Use**
+ *
+ * Use this function to run an Effect as your application’s main program, especially
+ * when you need structured error handling, log management, interrupt support,
+ * or advanced teardown capabilities.
+ *
  * @since 1.0.0
- * @category runtime
+ * @category Run main
  */
-export const runMain: RunMain = NodeRuntime.runMain
+export const runMain: {
+  /**
+   * Helps you run a main effect with built-in error handling, logging, and signal management.
+   *
+   * **Details**
+   *
+   * This function launches an Effect as the main entry point, setting exit codes
+   * based on success or failure, handling interrupts (e.g., Ctrl+C), and optionally
+   * logging errors. By default, it logs errors and uses a "pretty" format, but both
+   * behaviors can be turned off. You can also provide custom teardown logic to
+   * finalize resources or produce different exit codes.
+   *
+   * **Options**
+   *
+   * An optional object that can include:
+   * - `disableErrorReporting`: Turn off automatic error logging.
+   * - `disablePrettyLogger`: Avoid adding the pretty logger.
+   * - `teardown`: Provide custom finalization logic.
+   *
+   * **When to Use**
+   *
+   * Use this function to run an Effect as your application’s main program, especially
+   * when you need structured error handling, log management, interrupt support,
+   * or advanced teardown capabilities.
+   *
+   * @since 1.0.0
+   * @category Run main
+   */
+  (
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly teardown?: Teardown | undefined
+    }
+  ): <E, A>(effect: Effect<A, E>) => void
+  /**
+   * Helps you run a main effect with built-in error handling, logging, and signal management.
+   *
+   * **Details**
+   *
+   * This function launches an Effect as the main entry point, setting exit codes
+   * based on success or failure, handling interrupts (e.g., Ctrl+C), and optionally
+   * logging errors. By default, it logs errors and uses a "pretty" format, but both
+   * behaviors can be turned off. You can also provide custom teardown logic to
+   * finalize resources or produce different exit codes.
+   *
+   * **Options**
+   *
+   * An optional object that can include:
+   * - `disableErrorReporting`: Turn off automatic error logging.
+   * - `disablePrettyLogger`: Avoid adding the pretty logger.
+   * - `teardown`: Provide custom finalization logic.
+   *
+   * **When to Use**
+   *
+   * Use this function to run an Effect as your application’s main program, especially
+   * when you need structured error handling, log management, interrupt support,
+   * or advanced teardown capabilities.
+   *
+   * @since 1.0.0
+   * @category Run main
+   */
+  <E, A>(
+    effect: Effect<A, E>,
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly teardown?: Teardown | undefined
+    }
+  ): void
+} = NodeRuntime.runMain

package/src/BunServices.ts

@@ -0,0 +1,33 @@
+/**
+ * @since 1.0.0
+ */
+import type { FileSystem } from "effect/FileSystem"
+import * as Layer from "effect/Layer"
+import type { Path } from "effect/Path"
+import type { Stdio } from "effect/Stdio"
+import type { Terminal } from "effect/Terminal"
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
+import * as BunChildProcessSpawner from "./BunChildProcessSpawner.ts"
+import * as BunFileSystem from "./BunFileSystem.ts"
+import * as BunPath from "./BunPath.ts"
+import * as BunStdio from "./BunStdio.ts"
+import * as BunTerminal from "./BunTerminal.ts"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type BunServices = ChildProcessSpawner | FileSystem | Path | Terminal | Stdio
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+export const layer: Layer.Layer<BunServices> = BunChildProcessSpawner.layer.pipe(
+  Layer.provideMerge(Layer.mergeAll(
+    BunFileSystem.layer,
+    BunPath.layer,
+    BunStdio.layer,
+    BunTerminal.layer
+  ))
+)

package/src/BunSocket.ts

@@ -1,8 +1,11 @@
 /**
  * @since 1.0.0
  */
-import * as Socket from "@effect/platform/Socket"
+import type * as Duration from "effect/Duration"
+import type { Effect } from "effect/Effect"
+import { flow } from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as Socket from "effect/unstable/socket/Socket"
 
 /**
  * @since 1.0.0
@@ -13,18 +16,25 @@ export * from "@effect/platform-node-shared/NodeSocket"
  * @since 1.0.0
  * @category layers
  */
-export const layerWebSocket = (url: string, options?: {
-  readonly closeCodeIsError?: (code: number) => boolean
-}): Layer.Layer<Socket.Socket> =>
-  Layer.scoped(Socket.Socket, Socket.makeWebSocket(url, options)).pipe(
-    Layer.provide(layerWebSocketConstructor)
-  )
+export const layerWebSocketConstructor: Layer.Layer<
+  Socket.WebSocketConstructor
+> = Layer.succeed(Socket.WebSocketConstructor)(
+  (url, protocols) => new globalThis.WebSocket(url, protocols)
+)
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerWebSocketConstructor: Layer.Layer<Socket.WebSocketConstructor> = Layer.succeed(
-  Socket.WebSocketConstructor,
-  (url, protocols) => new globalThis.WebSocket(url, protocols)
+export const layerWebSocket: (
+  url: string | Effect<string>,
+  options?: {
+    readonly closeCodeIsError?: ((code: number) => boolean) | undefined
+    readonly openTimeout?: Duration.DurationInput | undefined
+    readonly protocols?: string | Array<string> | undefined
+  } | undefined
+) => Layer.Layer<Socket.Socket, never, never> = flow(
+  Socket.makeWebSocket,
+  Layer.effect(Socket.Socket),
+  Layer.provide(layerWebSocketConstructor)
 )

package/src/BunStdio.ts

@@ -0,0 +1,12 @@
+/**
+ * @since 1.0.0
+ */
+import * as NodeStdio from "@effect/platform-node-shared/NodeStdio"
+import type * as Layer from "effect/Layer"
+import type { Stdio } from "effect/Stdio"
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+export const layer: Layer.Layer<Stdio> = NodeStdio.layer

package/src/BunStream.ts

@@ -1,8 +1,59 @@
 /**
  * @since 1.0.0
  */
+import * as Arr from "effect/Array"
+import * as Cause from "effect/Cause"
+import * as Channel from "effect/Channel"
+import * as Effect from "effect/Effect"
+import type { LazyArg } from "effect/Function"
+import type * as Pull from "effect/Pull"
+import * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
 
 /**
  * @since 1.0.0
  */
 export * from "@effect/platform-node-shared/NodeStream"
+
+/**
+ * An optimized version of `Stream.fromReadableStream` that uses the Bun
+ * .readMany API to read multiple values at once from a `ReadableStream`.
+ *
+ * @since 1.0.0
+ */
+export const fromReadableStream = <A, E>(
+  options: {
+    readonly evaluate: LazyArg<ReadableStream<A>>
+    readonly onError: (error: unknown) => E
+    readonly releaseLockOnEnd?: boolean | undefined
+  }
+): Stream.Stream<A, E> =>
+  Stream.fromChannel(Channel.fromTransform(Effect.fnUntraced(function*(_, scope) {
+    const reader = options.evaluate().getReader()
+    yield* Scope.addFinalizer(
+      scope,
+      options.releaseLockOnEnd ? Effect.sync(() => reader.releaseLock()) : Effect.promise(() => reader.cancel())
+    )
+    const readMany = Effect.callback<Bun.ReadableStreamDefaultReadManyResult<A>, E>((resume) => {
+      const result = reader.readMany()
+      if ("then" in result) {
+        result.then((_) => resume(Effect.succeed(_)), (e) => resume(Effect.fail(options.onError(e))))
+      } else {
+        resume(Effect.succeed(result))
+      }
+    })
+    // @effect-diagnostics-next-line returnEffectInGen:off
+    return Effect.flatMap(
+      readMany,
+      function loop(
+        { done, value }
+      ): Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E> {
+        if (done) {
+          return Cause.done()
+        } else if (!Arr.isReadonlyArrayNonEmpty(value)) {
+          return Effect.flatMap(readMany, loop)
+        }
+        return Effect.succeed(value)
+      }
+    )
+  })))

package/src/BunTerminal.ts

@@ -2,10 +2,10 @@
  * @since 1.0.0
  */
 import * as NodeTerminal from "@effect/platform-node-shared/NodeTerminal"
-import type { Terminal, UserInput } from "@effect/platform/Terminal"
 import type { Effect } from "effect/Effect"
 import type { Layer } from "effect/Layer"
 import type { Scope } from "effect/Scope"
+import type { Terminal, UserInput } from "effect/Terminal"
 
 /**
  * @since 1.0.0
@@ -15,6 +15,6 @@ export const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Termin
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category layers
  */
 export const layer: Layer<Terminal> = NodeTerminal.layer

package/src/BunWorker.ts

@@ -1,34 +1,76 @@
 /**
  * @since 1.0.0
  */
-import type * as Worker from "@effect/platform/Worker"
-import type * as Layer from "effect/Layer"
-import * as internal from "./internal/worker.js"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import * as Worker from "effect/unstable/workers/Worker"
+import { WorkerError, WorkerUnknownError } from "effect/unstable/workers/WorkerError"
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerManager: Layer.Layer<Worker.WorkerManager> = internal.layerManager
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerWorker: Layer.Layer<Worker.PlatformWorker> = internal.layerWorker
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layer: (
-  spawn: (id: number) => Worker
-) => Layer.Layer<Worker.WorkerManager | Worker.Spawner, never, never> = internal.layer
+export const layer = (
+  spawn: (id: number) => globalThis.Worker
+): Layer.Layer<Worker.WorkerPlatform | Worker.Spawner> =>
+  Layer.merge(
+    layerPlatform,
+    Layer.succeed(Worker.Spawner)(spawn)
+  )
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerPlatform: (
-  spawn: (id: number) => globalThis.Worker
-) => Layer.Layer<Worker.PlatformWorker | Worker.Spawner, never, never> = internal.layerPlatform
+export const layerPlatform = Layer.succeed(Worker.WorkerPlatform)(
+  Worker.makePlatform<globalThis.Worker>()({
+    setup({ scope, worker }) {
+      const closeDeferred = Deferred.makeUnsafe<void>()
+      worker.addEventListener("close", () => {
+        Deferred.doneUnsafe(closeDeferred, Exit.void)
+      })
+      return Effect.as(
+        Scope.addFinalizer(
+          scope,
+          Effect.suspend(() => {
+            worker.postMessage([1])
+            return Deferred.await(closeDeferred)
+          }).pipe(
+            Effect.interruptible,
+            Effect.timeout(5000),
+            Effect.catchCause(() => Effect.sync(() => worker.terminate()))
+          )
+        ),
+        worker
+      )
+    },
+    listen({ deferred, emit, port, scope }) {
+      function onMessage(event: MessageEvent) {
+        emit(event.data)
+      }
+      function onError(event: ErrorEvent) {
+        Deferred.doneUnsafe(
+          deferred,
+          new WorkerError({
+            reason: new WorkerUnknownError({
+              message: "An error event was emitted",
+              cause: event.error ?? event.message
+            })
+          }).asEffect()
+        )
+      }
+      port.addEventListener("message", onMessage)
+      port.addEventListener("error", onError)
+      return Scope.addFinalizer(
+        scope,
+        Effect.sync(() => {
+          port.removeEventListener("message", onMessage)
+          port.removeEventListener("error", onError)
+        })
+      )
+    }
+  })
+)

package/src/BunWorkerRunner.ts

@@ -1,20 +1,101 @@
 /**
  * @since 1.0.0
  */
-import type * as Runner from "@effect/platform/WorkerRunner"
-import type * as Layer from "effect/Layer"
-import * as internal from "./internal/workerRunner.js"
+import * as Cause from "effect/Cause"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import { identity } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/unstable/workers/WorkerError"
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner"
 
-export {
-  /**
-   * @since 1.0.0
-   * @category re-exports
-   */
-  launch
-} from "@effect/platform/WorkerRunner"
+declare const self: MessagePort
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layer: Layer.Layer<Runner.PlatformRunner> = internal.layer
+export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start: Effect.fnUntraced(function*<O = unknown, I = unknown>() {
+    if (!("postMessage" in self)) {
+      return yield* new WorkerError({
+        reason: new WorkerSpawnError({ message: "not in a Worker context" })
+      })
+    }
+    const port = self
+    const run = <A, E, R>(
+      handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void
+    ) =>
+      Effect.scopedWith(Effect.fnUntraced(function*(scope) {
+        const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
+        const trackFiber = Fiber.runIn(scope)
+        const services = yield* Effect.services<R>()
+        const runFork = Effect.runForkWith(services)
+        const onExit = (exit: Exit.Exit<any, E>) => {
+          if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+            runFork(Effect.logError("unhandled error in worker", exit.cause))
+          }
+        }
+
+        function onMessage(event: MessageEvent) {
+          const message = (event as MessageEvent).data as WorkerRunner.PlatformMessage<I>
+          if (message[0] === 0) {
+            const result = handler(0, message[1])
+            if (Effect.isEffect(result)) {
+              const fiber = runFork(result)
+              fiber.addObserver(onExit)
+              trackFiber(fiber)
+            }
+          } else {
+            port.close()
+            Deferred.doneUnsafe(closeLatch, Exit.void)
+          }
+        }
+        function onMessageError(error: MessageEvent) {
+          Deferred.doneUnsafe(
+            closeLatch,
+            new WorkerError({
+              reason: new WorkerReceiveError({
+                message: "received messageerror event",
+                cause: error.data
+              })
+            }).asEffect()
+          )
+        }
+        function onError(error: MessageEvent) {
+          Deferred.doneUnsafe(
+            closeLatch,
+            new WorkerError({
+              reason: new WorkerReceiveError({
+                message: "received error event",
+                cause: error.data
+              })
+            }).asEffect()
+          )
+        }
+        yield* Scope.addFinalizer(
+          scope,
+          Effect.sync(() => {
+            port.removeEventListener("message", onMessage)
+            port.removeEventListener("messageerror", onError)
+          })
+        )
+        port.addEventListener("message", onMessage)
+        port.addEventListener("messageerror", onMessageError)
+        port.postMessage([0])
+
+        return yield* Deferred.await(closeLatch)
+      }))
+
+    const sendUnsafe = (_portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
+      port.postMessage([1, message], {
+        transfer: transfer as any
+      })
+    const send = (_portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
+      Effect.sync(() => sendUnsafe(0, message, transfer))
+    return identity<WorkerRunner.WorkerRunner<any, any>>({ run, send, sendUnsafe })
+  })
+})