@effect/platform-node 0.104.0 → 4.0.0-beta.0

package/src/NodeHttpServerRequest.ts

@@ -1,20 +1,20 @@
 /**
  * @since 1.0.0
  */
-import type * as ServerRequest from "@effect/platform/HttpServerRequest"
+import type { HttpServerRequest } from "effect/unstable/http/HttpServerRequest"
 import type * as Http from "node:http"
-import * as internal from "./internal/httpServer.js"
 
 /**
- * @category conversions
  * @since 1.0.0
+ * @category Accessors
  */
-export const toIncomingMessage: (self: ServerRequest.HttpServerRequest) => Http.IncomingMessage =
-  internal.toIncomingMessage
+export const toIncomingMessage = (self: HttpServerRequest): Http.IncomingMessage => self.source as any
 
 /**
- * @category conversions
  * @since 1.0.0
+ * @category Accessors
  */
-export const toServerResponse: (self: ServerRequest.HttpServerRequest) => Http.ServerResponse =
-  internal.toServerResponse
+export const toServerResponse = (self: HttpServerRequest): Http.ServerResponse => {
+  const res = (self as any).response
+  return typeof res === "function" ? res() : res
+}

package/src/NodeMultipart.ts

@@ -1,8 +1,163 @@
 /**
  * @since 1.0.0
  */
+import * as Effect from "effect/Effect"
+import type * as FileSystem from "effect/FileSystem"
+import * as Inspectable from "effect/Inspectable"
+import type * as Path from "effect/Path"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+import * as Multipart from "effect/unstable/http/Multipart"
+import * as MP from "effect/unstable/http/Multipasta/Node"
+import * as NFS from "node:fs"
+import type { IncomingHttpHeaders } from "node:http"
+import type { Readable } from "node:stream"
+import * as NodeStreamP from "node:stream/promises"
+import * as NodeStream from "./NodeStream.ts"
 
 /**
  * @since 1.0.0
+ * @category constructors
  */
-export * from "@effect/platform-node-shared/NodeMultipart"
+export const stream = (
+  source: Readable,
+  headers: IncomingHttpHeaders
+): Stream.Stream<Multipart.Part, Multipart.MultipartError> =>
+  Multipart.makeConfig(headers as any).pipe(
+    Effect.map((config) =>
+      NodeStream.fromReadable<MP.Part, Multipart.MultipartError>({
+        evaluate() {
+          const parser = MP.make(config)
+          source.pipe(parser)
+          return parser as any
+        },
+        onError: (error) => convertError(error as any)
+      })
+    ),
+    Stream.unwrap,
+    Stream.map(convertPart)
+  )
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const persisted = (
+  source: Readable,
+  headers: IncomingHttpHeaders
+): Effect.Effect<
+  Multipart.Persisted,
+  Multipart.MultipartError,
+  Scope.Scope | FileSystem.FileSystem | Path.Path
+> =>
+  Multipart.toPersisted(stream(source, headers), (path, file) =>
+    Effect.tryPromise({
+      try: (signal) => NodeStreamP.pipeline((file as FileImpl).file, NFS.createWriteStream(path), { signal }),
+      catch: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+    }))
+
+/**
+ * @since 1.0.0
+ */
+export const fileToReadable = (file: Multipart.File): Readable => (file as FileImpl).file
+
+// -----------------------------------------------------------------------------
+// Internal
+// -----------------------------------------------------------------------------
+
+const convertPart = (part: MP.Part): Multipart.Part =>
+  part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part)
+
+abstract class PartBase extends Inspectable.Class {
+  readonly [Multipart.TypeId]: typeof Multipart.TypeId
+  constructor() {
+    super()
+    this[Multipart.TypeId] = Multipart.TypeId
+  }
+}
+
+class FieldImpl extends PartBase implements Multipart.Field {
+  readonly _tag = "Field"
+  readonly key: string
+  readonly contentType: string
+  readonly value: string
+
+  constructor(
+    info: MP.PartInfo,
+    value: Uint8Array
+  ) {
+    super()
+    this.key = info.name
+    this.contentType = info.contentType
+    this.value = MP.decodeField(info, value)
+  }
+
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "Field",
+      key: this.key,
+      value: this.value,
+      contentType: this.contentType
+    }
+  }
+}
+
+class FileImpl extends PartBase implements Multipart.File {
+  readonly _tag = "File"
+  readonly key: string
+  readonly name: string
+  readonly contentType: string
+  readonly content: Stream.Stream<Uint8Array, Multipart.MultipartError>
+  readonly contentEffect: Effect.Effect<Uint8Array, Multipart.MultipartError>
+  readonly file: MP.FileStream
+
+  constructor(file: MP.FileStream) {
+    super()
+    this.file = file
+    this.key = file.info.name
+    this.name = file.filename ?? file.info.name
+    this.contentType = file.info.contentType
+    this.content = NodeStream.fromReadable({
+      evaluate: () => file,
+      onError: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+    })
+    this.contentEffect = NodeStream.toUint8Array(() => file, {
+      onError: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+    })
+  }
+
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "File",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType
+    }
+  }
+}
+
+function convertError(cause: MP.MultipartError): Multipart.MultipartError {
+  switch (cause._tag) {
+    case "ReachedLimit": {
+      switch (cause.limit) {
+        case "MaxParts": {
+          return Multipart.MultipartError.fromReason("TooManyParts", cause)
+        }
+        case "MaxFieldSize": {
+          return Multipart.MultipartError.fromReason("FieldTooLarge", cause)
+        }
+        case "MaxPartSize": {
+          return Multipart.MultipartError.fromReason("FileTooLarge", cause)
+        }
+        case "MaxTotalSize": {
+          return Multipart.MultipartError.fromReason("BodyTooLarge", cause)
+        }
+      }
+    }
+    default: {
+      return Multipart.MultipartError.fromReason("Parse", cause)
+    }
+  }
+}

package/src/NodePath.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/NodeRedis.ts

@@ -0,0 +1,74 @@
+/**
+ * @since 1.0.0
+ */
+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"
+import * as IoRedis from "ioredis"
+
+/**
+ * @since 1.0.0
+ * @category Service
+ */
+export class NodeRedis extends ServiceMap.Service<NodeRedis, {
+  readonly client: IoRedis.Redis
+  readonly use: <A>(f: (client: IoRedis.Redis) => Promise<A>) => Effect.Effect<A, Redis.RedisError>
+}>()("@effect/platform-node/NodeRedis") {}
+
+const make = Effect.fnUntraced(function*(
+  options?: IoRedis.RedisOptions
+) {
+  const scope = yield* Effect.scope
+  yield* Scope.addFinalizer(scope, Effect.promise(() => client.quit()))
+  const client = new IoRedis.Redis(options ?? {})
+
+  const use = <A>(f: (client: IoRedis.Redis) => 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.call(command, ...args) as Promise<A>,
+        catch: (cause) => new Redis.RedisError({ cause })
+      })
+  })
+
+  const nodeRedis = Fn.identity<NodeRedis["Service"]>({
+    client,
+    use
+  })
+
+  return ServiceMap.make(NodeRedis, nodeRedis).pipe(
+    ServiceMap.add(Redis.Redis, redis)
+  )
+})
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layer = (
+  options?: IoRedis.RedisOptions | undefined
+): Layer.Layer<Redis.Redis | NodeRedis> => Layer.effectServices(make(options))
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerConfig: (
+  options: Config.Wrap<IoRedis.RedisOptions>
+) => Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> = (
+  options: Config.Wrap<IoRedis.RedisOptions>
+): Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> =>
+  Layer.effectServices(
+    Config.unwrap(options).asEffect().pipe(
+      Effect.flatMap(make)
+    )
+  )

package/src/NodeRuntime.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 * as Runtime 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?: Runtime.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?: Runtime.Teardown | undefined
+    }
+  ): void
+} = NodeRuntime.runMain

package/src/NodeServices.ts

@@ -0,0 +1,34 @@
+/**
+ * @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 NodeChildProcessSpawner from "./NodeChildProcessSpawner.ts"
+import * as NodeFileSystem from "./NodeFileSystem.ts"
+import * as NodePath from "./NodePath.ts"
+import * as NodeStdio from "./NodeStdio.ts"
+import * as NodeTerminal from "./NodeTerminal.ts"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type NodeServices = ChildProcessSpawner | FileSystem | Path | Stdio | Terminal
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+export const layer: Layer.Layer<NodeServices> = Layer.provideMerge(
+  NodeChildProcessSpawner.layer,
+  Layer.mergeAll(
+    NodeFileSystem.layer,
+    NodePath.layer,
+    NodeStdio.layer,
+    NodeTerminal.layer
+  )
+)

package/src/NodeSocket.ts

@@ -1,9 +1,12 @@
 /**
  * @since 1.0.0
  */
-import * as Socket from "@effect/platform/Socket"
+import { NodeWS as WS } from "@effect/platform-node-shared/NodeSocket"
+import type * as Duration from "effect/Duration"
+import type * as Effect from "effect/Effect"
+import { flow } from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as WS from "ws"
+import * as Socket from "effect/unstable/socket/Socket"
 
 /**
  * @since 1.0.0
@@ -14,23 +17,28 @@ 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.sync(Socket.WebSocketConstructor)(() => {
+  if ("WebSocket" in globalThis) {
+    return (url, protocols) => new globalThis.WebSocket(url, protocols)
+  }
+  return (url, protocols) => new WS.WebSocket(url, protocols) as unknown as globalThis.WebSocket
+})
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerWebSocketConstructor: Layer.Layer<Socket.WebSocketConstructor> = Layer.sync(
-  Socket.WebSocketConstructor,
-  () => {
-    if ("WebSocket" in globalThis) {
-      return (url, protocols) => new globalThis.WebSocket(url, protocols)
-    }
-    return (url, protocols) => new WS.WebSocket(url, protocols) as unknown as globalThis.WebSocket
-  }
+export const layerWebSocket: (
+  url: string | Effect.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/NodeStdio.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/NodeStream.ts

@@ -3,6 +3,6 @@
  */
 
 /**
- * @category models
+ * @since 1.0.0
  */
 export * from "@effect/platform-node-shared/NodeStream"

package/src/NodeTerminal.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/NodeWorker.ts

@@ -1,36 +1,105 @@
 /**
  * @since 1.0.0
  */
-import type * as Worker from "@effect/platform/Worker"
-import type * as Layer from "effect/Layer"
+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, WorkerReceiveError } from "effect/unstable/workers/WorkerError"
 import type * as ChildProcess from "node:child_process"
 import type * as WorkerThreads from "node:worker_threads"
-import * as internal from "./internal/worker.js"
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerManager: Layer.Layer<Worker.WorkerManager> = internal.layerManager
+export const layerPlatform: Layer.Layer<Worker.WorkerPlatform> = Layer.succeed(Worker.WorkerPlatform)(
+  Worker.makePlatform<WorkerThreads.Worker | ChildProcess.ChildProcess>()({
+    setup({ scope, worker }) {
+      const exitDeferred = Deferred.makeUnsafe<void, WorkerError>()
+      const thing = "postMessage" in worker ?
+        {
+          postMessage(msg: any, t?: any) {
+            worker.postMessage(msg, t)
+          },
+          kill: () => worker.terminate(),
+          worker
+        } :
+        {
+          postMessage(msg: any, _?: any) {
+            worker.send(msg)
+          },
+          kill: () => worker.kill("SIGKILL"),
+          worker
+        }
+      worker.on("exit", () => {
+        Deferred.doneUnsafe(exitDeferred, Exit.void)
+      })
+      return Effect.as(
+        Scope.addFinalizer(
+          scope,
+          Effect.suspend(() => {
+            thing.postMessage([1])
+            return Deferred.await(exitDeferred)
+          }).pipe(
+            Effect.timeout(5000),
+            Effect.catchCause(() => Effect.sync(() => thing.kill()))
+          )
+        ),
+        thing
+      )
+    },
+    listen({ deferred, emit, port }) {
+      port.worker.on("message", (message) => {
+        emit(message)
+      })
+      port.worker.on("messageerror", (cause) => {
+        Deferred.doneUnsafe(
+          deferred,
+          new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "An messageerror event was emitted",
+              cause
+            })
+          }).asEffect()
+        )
+      })
+      port.worker.on("error", (cause) => {
+        Deferred.doneUnsafe(
+          deferred,
+          new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "An error event was emitted",
+              cause
+            })
+          }).asEffect()
+        )
+      })
+      port.worker.on("exit", (code) => {
+        Deferred.doneUnsafe(
+          deferred,
+          new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "The worker has exited with code: " + code
+            })
+          }).asEffect()
+        )
+      })
+      return Effect.void
+    }
+  })
+)
 
 /**
  * @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) => WorkerThreads.Worker | ChildProcess.ChildProcess
-) => Layer.Layer<Worker.WorkerManager | Worker.Spawner> = internal.layer
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerPlatform: (
+export const layer = (
   spawn: (id: number) => WorkerThreads.Worker | ChildProcess.ChildProcess
-) => Layer.Layer<Worker.PlatformWorker | Worker.Spawner> = internal.layerPlatform
+): Layer.Layer<Worker.WorkerPlatform | Worker.Spawner> =>
+  Layer.merge(
+    Worker.layerSpawner(spawn),
+    layerPlatform
+  )