@effect/platform-node 0.19.9 → 0.20.1

package/CommandExecutor/dist/effect-platform-node-CommandExecutor.esm.js

@@ -1,15 +1,160 @@
-export { l as layer } from '../../dist/CommandExecutor-cfc0af4b.esm.js';
+import * as Command from '@effect/platform/Command';
+import * as CommandExecutor from '@effect/platform/CommandExecutor';
 export { CommandExecutor } from '@effect/platform/CommandExecutor';
-import '@effect/platform/Command';
-import '@effect/platform/FileSystem';
-import 'effect/Effect';
-import 'effect/Function';
-import 'effect/Layer';
-import 'effect/Option';
-import 'effect/Sink';
-import 'effect/Stream';
-import 'node:child_process';
-import '../../dist/error-4865cb95.esm.js';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Effect from 'effect/Effect';
+import { pipe, constUndefined } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Sink from 'effect/Sink';
+import * as Stream from 'effect/Stream';
+import * as ChildProcess from 'node:child_process';
+import { h as handleErrnoException } from '../../dist/error-4865cb95.esm.js';
+import { f as fromWritable } from '../../dist/sink-bd7ef408.esm.js';
+import { f as fromReadable } from '../../dist/stream-860139d3.esm.js';
 import '@effect/platform/Error';
-import '../../dist/sink-bd7ef408.esm.js';
-import '../../dist/stream-860139d3.esm.js';
+
+const inputToStdioOption = stdin => Option.match(stdin, {
+  onNone: () => "inherit",
+  onSome: () => "pipe"
+});
+const outputToStdioOption = output => typeof output === "string" ? output : "pipe";
+const toError = err => err instanceof globalThis.Error ? err : new globalThis.Error(String(err));
+const toPlatformError = (method, error, command) => {
+  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]);
+};
+const runCommand = fileSystem => command => {
+  switch (command._tag) {
+    case "StandardCommand":
+      {
+        return pipe(
+        // Validate that the directory is accessible
+        Option.match(command.cwd, {
+          onNone: () => Effect.unit,
+          onSome: dir => fileSystem.access(dir)
+        }), Effect.zipRight(Effect.sync(() => globalThis.process.env)), Effect.flatMap(env => Effect.async(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),
+            env: {
+              ...env,
+              ...Object.fromEntries(command.env)
+            }
+          });
+          let exited = false;
+          handle.on("exit", () => {
+            exited = true;
+          });
+
+          // If starting the process throws an error, make sure to capture it
+          handle.on("error", err => {
+            handle.kill("SIGKILL");
+            resume(Effect.fail(toPlatformError("spawn", err, command)));
+          });
+
+          // If the process is assigned a process identifier, then we know it
+          // was spawned successfully
+          if (handle.pid) {
+            let stdin = Sink.drain;
+            if (handle.stdin !== null) {
+              stdin = fromWritable(() => handle.stdin, err => toPlatformError("toWritable", toError(err), command));
+            }
+            const exitCode = Effect.async(resume => {
+              if (exited) {
+                return resume(handle.exitCode !== null ? Effect.succeed(CommandExecutor.ExitCode(handle.exitCode)) : Effect.fail(toPlatformError("exitCode", new globalThis.Error(`Process interrupted due to receipt of signal: ${handle.signalCode}`), command)));
+              }
+              handle.on("exit", (code, signal) => {
+                if (code !== null) {
+                  resume(Effect.succeed(CommandExecutor.ExitCode(code)));
+                } else {
+                  // 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
+                  resume(Effect.fail(toPlatformError("exitCode", new globalThis.Error(`Process interrupted due to receipt of signal: ${signal}`), command)));
+                }
+              });
+              // Make sure to terminate the running process if the fiber is
+              // terminated
+              return Effect.sync(() => {
+                handle.kill("SIGKILL");
+              });
+            });
+            const isRunning = Effect.sync(() => handle.exitCode === null && handle.signalCode === null && !handle.killed);
+            const kill = (signal = "SIGTERM") => Effect.async(resume => {
+              handle.kill(signal);
+              handle.on("exit", () => {
+                resume(Effect.unit);
+              });
+              // Make sure to terminate the running process if the fiber
+              // is terminated
+              return Effect.sync(() => {
+                handle.kill("SIGKILL");
+              });
+            });
+            resume(Effect.sync(() => {
+              const pid = CommandExecutor.ProcessId(handle.pid);
+              const stderr = fromReadable(() => handle.stderr, err => toPlatformError("fromReadable(stderr)", toError(err), command));
+              let stdout = fromReadable(() => 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
+              };
+            }));
+          }
+          return Effect.async(resume => {
+            if (handle.pid) {
+              handle.kill("SIGTERM");
+            }
+            handle.on("exit", () => {
+              resume(Effect.unit);
+            });
+          });
+        })), 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), Stream.flatMap(process => process.stdout)), pipe(runCommand(fileSystem)(head), Stream.flatMap(process => process.stdout)));
+        return pipe(Command.stdin(last, stream), runCommand(fileSystem));
+      }
+  }
+};
+
+/** @internal */
+const layer$1 = /*#__PURE__*/Layer.effect(CommandExecutor.CommandExecutor, /*#__PURE__*/pipe(FileSystem.FileSystem, /*#__PURE__*/Effect.map(fileSystem => CommandExecutor.makeExecutor(runCommand(fileSystem)))));
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+const layer = layer$1;
+
+export { layer };

package/Effectify/dist/effect-platform-node-Effectify.cjs.dev.js

@@ -7,6 +7,6 @@ var Effectify = require('@effect/platform/Effectify');
 
 
 Object.defineProperty(exports, 'effectify', {
-	enumerable: true,
-	get: function () { return Effectify.effectify; }
+  enumerable: true,
+  get: function () { return Effectify.effectify; }
 });

package/Effectify/dist/effect-platform-node-Effectify.cjs.prod.js

@@ -7,6 +7,6 @@ var Effectify = require('@effect/platform/Effectify');
 
 
 Object.defineProperty(exports, 'effectify', {
-	enumerable: true,
-	get: function () { return Effectify.effectify; }
+  enumerable: true,
+  get: function () { return Effectify.effectify; }
 });

package/Error/dist/effect-platform-node-Error.cjs.dev.js

@@ -7,14 +7,14 @@ var Error = require('@effect/platform/Error');
 
 
 Object.defineProperty(exports, 'BadArgument', {
-	enumerable: true,
-	get: function () { return Error.BadArgument; }
+  enumerable: true,
+  get: function () { return Error.BadArgument; }
 });
 Object.defineProperty(exports, 'PlatformErrorTypeId', {
-	enumerable: true,
-	get: function () { return Error.PlatformErrorTypeId; }
+  enumerable: true,
+  get: function () { return Error.PlatformErrorTypeId; }
 });
 Object.defineProperty(exports, 'SystemError', {
-	enumerable: true,
-	get: function () { return Error.SystemError; }
+  enumerable: true,
+  get: function () { return Error.SystemError; }
 });

package/Error/dist/effect-platform-node-Error.cjs.prod.js

@@ -7,14 +7,14 @@ var Error = require('@effect/platform/Error');
 
 
 Object.defineProperty(exports, 'BadArgument', {
-	enumerable: true,
-	get: function () { return Error.BadArgument; }
+  enumerable: true,
+  get: function () { return Error.BadArgument; }
 });
 Object.defineProperty(exports, 'PlatformErrorTypeId', {
-	enumerable: true,
-	get: function () { return Error.PlatformErrorTypeId; }
+  enumerable: true,
+  get: function () { return Error.PlatformErrorTypeId; }
 });
 Object.defineProperty(exports, 'SystemError', {
-	enumerable: true,
-	get: function () { return Error.SystemError; }
+  enumerable: true,
+  get: function () { return Error.SystemError; }
 });