@effect/platform-node-shared 0.0.0-snapshot-c0ae728e57df2c572ea803e1bb7121088cd67b49

package/src/NodeStream.ts

@@ -0,0 +1,109 @@
+/**
+ * @since 1.0.0
+ */
+import type { PlatformError } from "@effect/platform/Error"
+import type { SizeInput } from "@effect/platform/FileSystem"
+import type { Channel } from "effect/Channel"
+import type { Chunk } from "effect/Chunk"
+import type { Effect } from "effect/Effect"
+import type { LazyArg } from "effect/Function"
+import type { Stream } from "effect/Stream"
+import type { Duplex, Readable } from "node:stream"
+import * as internal from "./internal/stream.js"
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface FromReadableOptions {
+  /** Defaults to undefined, which lets Node.js decide the chunk size */
+  readonly chunkSize?: SizeInput
+}
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+export interface FromWritableOptions {
+  readonly endOnDone?: boolean
+  readonly encoding?: BufferEncoding
+}
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+export const fromReadable: <E, A = Uint8Array>(
+  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
+  onError: (error: unknown) => E,
+  { chunkSize }?: FromReadableOptions
+) => Stream<A, E> = internal.fromReadable
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+export const fromReadableChannel: <E, A = Uint8Array>(
+  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
+  onError: (error: unknown) => E,
+  chunkSize: number | undefined
+) => Channel<never, unknown, unknown, unknown, E, Chunk<A>, void> = internal.fromReadableChannel
+
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+export const fromDuplex: <IE, E, I = Uint8Array, O = Uint8Array>(
+  evaluate: LazyArg<Duplex>,
+  onError: (error: unknown) => E,
+  options?: FromReadableOptions & FromWritableOptions
+) => Channel<never, IE, Chunk<I>, unknown, IE | E, Chunk<O>, void> = internal.fromDuplex
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+export const pipeThroughDuplex: {
+  <E2, B = Uint8Array>(
+    duplex: LazyArg<Duplex>,
+    onError: (error: unknown) => E2,
+    options?: (FromReadableOptions & FromWritableOptions) | undefined
+  ): <R, E, A>(self: Stream<A, E, R>) => Stream<B, E2 | E, R>
+  <R, E, A, E2, B = Uint8Array>(
+    self: Stream<A, E, R>,
+    duplex: LazyArg<Duplex>,
+    onError: (error: unknown) => E2,
+    options?: (FromReadableOptions & FromWritableOptions) | undefined
+  ): Stream<B, E | E2, R>
+} = internal.pipeThroughDuplex
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+export const pipeThroughSimple: {
+  (duplex: LazyArg<Duplex>): <R, E>(self: Stream<string | Uint8Array, E, R>) => Stream<Uint8Array, E | PlatformError, R>
+  <R, E>(self: Stream<string | Uint8Array, E, R>, duplex: LazyArg<Duplex>): Stream<Uint8Array, PlatformError | E, R>
+} = internal.pipeThroughSimple
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toString: <E>(
+  readable: LazyArg<Readable | NodeJS.ReadableStream>,
+  options: {
+    readonly onFailure: (error: unknown) => E
+    readonly encoding?: BufferEncoding | undefined
+    readonly maxBytes?: SizeInput | undefined
+  }
+) => Effect<string, E> = internal.toString
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toUint8Array: <E>(
+  readable: LazyArg<Readable | NodeJS.ReadableStream>,
+  options: { readonly onFailure: (error: unknown) => E; readonly maxBytes?: SizeInput | undefined }
+) => Effect<Uint8Array, E> = internal.toUint8Array

package/src/NodeTerminal.ts

@@ -0,0 +1,20 @@
+/**
+ * @since 1.0.0
+ */
+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 * as InternalTerminal from "./internal/terminal.js"
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Terminal, never, Scope> =
+  InternalTerminal.make
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+export const layer: Layer<Terminal> = InternalTerminal.layer

package/src/internal/commandExecutor.ts

@@ -0,0 +1,203 @@
+import * as Command from "@effect/platform/Command"
+import * as CommandExecutor from "@effect/platform/CommandExecutor"
+import type * as Error from "@effect/platform/Error"
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import { constUndefined, pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
+import * as Sink from "effect/Sink"
+import * as Stream from "effect/Stream"
+import * as ChildProcess from "node:child_process"
+import { handleErrnoException } from "./error.js"
+import { fromWritable } from "./sink.js"
+import { fromReadable } from "./stream.js"
+
+const inputToStdioOption = (stdin: Option.Option<Command.Command.Input>): "pipe" | "inherit" =>
+  Option.match(stdin, { onNone: () => "inherit", onSome: () => "pipe" })
+
+const outputToStdioOption = (output: Command.Command.Output): "pipe" | "inherit" =>
+  typeof output === "string" ? output : "pipe"
+
+const toError = (err: unknown): Error => err instanceof globalThis.Error ? err : new globalThis.Error(String(err))
+
+const toPlatformError = (
+  method: string,
+  error: NodeJS.ErrnoException,
+  command: Command.Command
+): Error.PlatformError => {
+  const flattened = Command.flatten(command).reduce((acc, curr) => {
+    const command = `${curr.command} ${curr.args.join(" ")}`
+    return acc.length === 0 ? command : `${acc} | ${command}`
+  }, "")
+  return handleErrnoException("Command", method)(error, [flattened])
+}
+
+type ExitCode = readonly [code: number | null, signal: NodeJS.Signals | null]
+type ExitCodeDeferred = Deferred.Deferred<never, ExitCode>
+
+const runCommand =
+  (fileSystem: FileSystem.FileSystem) =>
+  (command: Command.Command): Effect.Effect<CommandExecutor.Process, Error.PlatformError, Scope.Scope> => {
+    switch (command._tag) {
+      case "StandardCommand": {
+        const spawn = Effect.flatMap(
+          Deferred.make<never, ExitCode>(),
+          (exitCode) =>
+            Effect.async<readonly [ChildProcess.ChildProcess, ExitCodeDeferred], Error.PlatformError, never>(
+              (resume) => {
+                const handle = ChildProcess.spawn(command.command, command.args, {
+                  stdio: [
+                    inputToStdioOption(command.stdin),
+                    outputToStdioOption(command.stdout),
+                    outputToStdioOption(command.stderr)
+                  ],
+                  cwd: Option.getOrElse(command.cwd, constUndefined),
+                  shell: command.shell,
+                  env: { ...process.env, ...Object.fromEntries(command.env) }
+                })
+                handle.on("error", (err) => {
+                  resume(Effect.fail(toPlatformError("spawn", err, command)))
+                })
+                handle.on("exit", (...args) => {
+                  Deferred.unsafeDone(exitCode, Effect.succeed(args))
+                })
+                handle.on("spawn", () => {
+                  resume(Effect.succeed([handle, exitCode]))
+                })
+                return Effect.sync(() => {
+                  handle.kill("SIGTERM")
+                })
+              }
+            )
+        )
+        return pipe(
+          // Validate that the directory is accessible
+          Option.match(command.cwd, {
+            onNone: () => Effect.unit,
+            onSome: (dir) => fileSystem.access(dir)
+          }),
+          Effect.zipRight(
+            Effect.acquireRelease(
+              spawn,
+              ([handle, exitCode]) =>
+                Effect.flatMap(Deferred.isDone(exitCode), (done) =>
+                  done ? Effect.unit : Effect.suspend(() => {
+                    if (handle.kill("SIGTERM")) {
+                      return Deferred.await(exitCode)
+                    }
+                    return Effect.unit
+                  }))
+            )
+          ),
+          Effect.map(([handle, exitCodeDeferred]): CommandExecutor.Process => {
+            let stdin: Sink.Sink<never, Error.PlatformError, unknown, never, void> = Sink.drain
+
+            if (handle.stdin !== null) {
+              stdin = fromWritable(
+                () => handle.stdin!,
+                (err) => toPlatformError("toWritable", toError(err), command)
+              )
+            }
+
+            const exitCode: CommandExecutor.Process["exitCode"] = Effect.flatMap(
+              Deferred.await(exitCodeDeferred),
+              ([code, signal]) => {
+                if (code !== null) {
+                  return Effect.succeed(CommandExecutor.ExitCode(code))
+                }
+                // If code is `null`, then `signal` must be defined. See the NodeJS
+                // documentation for the `"exit"` event on a `child_process`.
+                // https://nodejs.org/api/child_process.html#child_process_event_exit
+                return Effect.fail(
+                  toPlatformError(
+                    "exitCode",
+                    new globalThis.Error(`Process interrupted due to receipt of signal: ${signal}`),
+                    command
+                  )
+                )
+              }
+            )
+
+            const isRunning = Effect.negate(Deferred.isDone(exitCodeDeferred))
+
+            const kill: CommandExecutor.Process["kill"] = (signal = "SIGTERM") =>
+              Effect.suspend(() =>
+                handle.kill(signal)
+                  ? Effect.asUnit(Deferred.await(exitCodeDeferred))
+                  : Effect.fail(toPlatformError("kill", new globalThis.Error("Failed to kill process"), command))
+              )
+
+            const pid = CommandExecutor.ProcessId(handle.pid!)
+            const stderr = fromReadable<Error.PlatformError, Uint8Array>(
+              () => handle.stderr!,
+              (err) => toPlatformError("fromReadable(stderr)", toError(err), command)
+            )
+            let stdout: Stream.Stream<Uint8Array, Error.PlatformError> = fromReadable<
+              Error.PlatformError,
+              Uint8Array
+            >(
+              () => handle.stdout!,
+              (err) => toPlatformError("fromReadable(stdout)", toError(err), command)
+            )
+            // TODO: add Sink.isSink
+            if (typeof command.stdout !== "string") {
+              stdout = Stream.transduce(stdout, command.stdout)
+            }
+            return {
+              [CommandExecutor.ProcessTypeId]: CommandExecutor.ProcessTypeId,
+              pid,
+              exitCode,
+              isRunning,
+              kill,
+              stdin,
+              stderr,
+              stdout
+            }
+          }),
+          Effect.tap((process) =>
+            Option.match(command.stdin, {
+              onNone: () => Effect.unit,
+              onSome: (stdin) => Effect.forkDaemon(Stream.run(stdin, process.stdin))
+            })
+          )
+        )
+      }
+      case "PipedCommand": {
+        const flattened = Command.flatten(command)
+        if (flattened.length === 1) {
+          return pipe(flattened[0], runCommand(fileSystem))
+        }
+        const head = flattened[0]
+        const tail = flattened.slice(1)
+        const initial = tail.slice(0, tail.length - 1)
+        const last = tail[tail.length - 1]
+        const stream = initial.reduce(
+          (stdin, command) =>
+            pipe(
+              Command.stdin(command, stdin),
+              runCommand(fileSystem),
+              Effect.map((process) => process.stdout),
+              Stream.unwrapScoped
+            ),
+          pipe(
+            runCommand(fileSystem)(head),
+            Effect.map((process) => process.stdout),
+            Stream.unwrapScoped
+          )
+        )
+        return pipe(Command.stdin(last, stream), runCommand(fileSystem))
+      }
+    }
+  }
+
+/** @internal */
+export const layer: Layer.Layer<CommandExecutor.CommandExecutor, never, FileSystem.FileSystem> = Layer.effect(
+  CommandExecutor.CommandExecutor,
+  pipe(
+    FileSystem.FileSystem,
+    Effect.map((fileSystem) => CommandExecutor.makeExecutor(runCommand(fileSystem)))
+  )
+)

package/src/internal/error.ts

@@ -0,0 +1,51 @@
+import type { PlatformError, SystemErrorReason } from "@effect/platform/Error"
+import { SystemError } from "@effect/platform/Error"
+import type { PathLike } from "node:fs"
+
+/** @internal */
+export const handleErrnoException = (module: SystemError["module"], method: string) =>
+(
+  err: NodeJS.ErrnoException,
+  [path]: [path: PathLike | number, ...args: Array<any>]
+): PlatformError => {
+  let reason: SystemErrorReason = "Unknown"
+
+  switch (err.code) {
+    case "ENOENT":
+      reason = "NotFound"
+      break
+
+    case "EACCES":
+      reason = "PermissionDenied"
+      break
+
+    case "EEXIST":
+      reason = "AlreadyExists"
+      break
+
+    case "EISDIR":
+      reason = "BadResource"
+      break
+
+    case "ENOTDIR":
+      reason = "BadResource"
+      break
+
+    case "EBUSY":
+      reason = "Busy"
+      break
+
+    case "ELOOP":
+      reason = "BadResource"
+      break
+  }
+
+  return SystemError({
+    reason,
+    module,
+    method,
+    pathOrDescriptor: path as string | number,
+    syscall: err.syscall,
+    message: err.message
+  })
+}