@effect/platform-node-shared 4.0.0-beta.4 → 4.0.0-beta.40

package/src/NodeFileSystem.ts

@@ -285,19 +285,19 @@ const makeFile = (() => {
         const position = this.position
         return Effect.map(
           nodeReadAlloc(this.fd, { buffer, position }),
-          (bytesRead): Buffer | undefined => {
+          (bytesRead): Option.Option<Buffer> => {
             if (bytesRead === 0) {
-              return undefined
+              return Option.none()
             }
 
             this.position = position + BigInt(bytesRead)
             if (bytesRead === sizeNumber) {
-              return buffer
+              return Option.some(buffer)
             }
 
             const dst = Buffer.allocUnsafeSlow(bytesRead)
             buffer.copy(dst, 0, 0, bytesRead)
-            return dst
+            return Option.some(dst)
           }
         )
       })
@@ -341,7 +341,7 @@ const makeFile = (() => {
                 Error.systemError({
                   module: "FileSystem",
                   method: "writeAll",
-                  kind: "WriteZero",
+                  _tag: "WriteZero",
                   pathOrDescriptor: this.fd,
                   description: "write returned 0 bytes written"
                 })
@@ -468,19 +468,19 @@ const makeFileInfo = (stat: NFS.Stats): FileSystem.File.Info => ({
     stat.isSocket() ?
     "Socket" :
     "Unknown",
-  mtime: stat.mtime,
-  atime: stat.atime,
-  birthtime: stat.birthtime,
+  mtime: Option.fromNullishOr(stat.mtime),
+  atime: Option.fromNullishOr(stat.atime),
+  birthtime: Option.fromNullishOr(stat.birthtime),
   dev: stat.dev,
-  rdev: stat.rdev,
-  ino: stat.ino,
+  rdev: Option.fromNullishOr(stat.rdev),
+  ino: Option.fromNullishOr(stat.ino),
   mode: stat.mode,
-  nlink: stat.nlink,
-  uid: stat.uid,
-  gid: stat.gid,
+  nlink: Option.fromNullishOr(stat.nlink),
+  uid: Option.fromNullishOr(stat.uid),
+  gid: Option.fromNullishOr(stat.gid),
   size: FileSystem.Size(stat.size),
-  blksize: FileSystem.Size(stat.blksize),
-  blocks: stat.blocks
+  blksize: stat.blksize !== undefined ? Option.some(FileSystem.Size(stat.blksize)) : Option.none(),
+  blocks: Option.fromNullishOr(stat.blocks)
 })
 const stat = (() => {
   const nodeStat = effectify(
@@ -531,7 +531,9 @@ const watchNode = (path: string) =>
   Stream.callback<FileSystem.WatchEvent, Error.PlatformError>((queue) =>
     Effect.acquireRelease(
       Effect.sync(() => {
-        const watcher = NFS.watch(path, {}, (event, path) => {
+        const watcher = NFS.watch(path, {
+          recursive: true
+        }, (event, path) => {
           if (!path) return
           switch (event) {
             case "rename": {
@@ -553,7 +555,7 @@ const watchNode = (path: string) =>
             Cause.fail(
               Error.systemError({
                 module: "FileSystem",
-                kind: "Unknown",
+                _tag: "Unknown",
                 method: "watch",
                 pathOrDescriptor: path,
                 cause: error
@@ -570,15 +572,14 @@ const watchNode = (path: string) =>
     )
   )
 
-const watch = (backend: FileSystem.WatchBackend["Service"] | undefined, path: string) =>
+const watch = (backend: Option.Option<FileSystem.WatchBackend["Service"]>, path: string) =>
   stat(path).pipe(
-    Effect.map((stat) => {
-      if (backend) {
-        const stream = backend.register(path, stat)
-        if (stream) return stream
-      }
-      return watchNode(path)
-    }),
+    Effect.map((stat) =>
+      backend.pipe(
+        Option.flatMap((_) => _.register(path, stat)),
+        Option.getOrElse(() => watchNode(path))
+      )
+    ),
     Stream.unwrap
   )
 
@@ -628,7 +629,7 @@ const makeFileSystem = Effect.map(Effect.serviceOption(FileSystem.WatchBackend),
     truncate,
     utimes,
     watch(path) {
-      return watch(Option.getOrUndefined(backend), path)
+      return watch(backend, path)
     },
     writeFile
   }))

package/src/NodeSink.ts

@@ -66,6 +66,13 @@ export const pullIntoWritable = <A, IE, E>(options: {
       })
     }),
     Effect.forever({ disableYield: true }),
+    Effect.raceFirst(Effect.callback<never, E>((resume) => {
+      const onError = (error: unknown) => resume(Effect.fail(options.onError(error)))
+      options.writable.once("error", onError)
+      return Effect.sync(() => {
+        options.writable.off("error", onError)
+      })
+    })),
     options.endOnDone !== false ?
       Pull.catchDone((_) => {
         if ("closed" in options.writable && options.writable.closed) {

package/src/NodeSocket.ts

@@ -9,6 +9,7 @@ import * as Effect from "effect/Effect"
 import * as FiberSet from "effect/FiberSet"
 import * as Function from "effect/Function"
 import { identity } from "effect/Function"
+import * as Latch from "effect/Latch"
 import * as Layer from "effect/Layer"
 import * as Scope from "effect/Scope"
 import * as ServiceMap from "effect/ServiceMap"
@@ -36,7 +37,7 @@ export class NetSocket extends ServiceMap.Service<NetSocket, Net.Socket>()(
  */
 export const makeNet = (
   options: Net.NetConnectOpts & {
-    readonly openTimeout?: Duration.DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
   }
 ): Effect.Effect<Socket.Socket> =>
   fromDuplex(
@@ -82,12 +83,12 @@ export const makeNet = (
 export const fromDuplex = <RO>(
   open: Effect.Effect<Duplex, Socket.SocketError, RO>,
   options?: {
-    readonly openTimeout?: Duration.DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
   }
 ): Effect.Effect<Socket.Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.withFiber<Socket.Socket, never, Exclude<RO, Scope.Scope>>((fiber) => {
     let currentSocket: Duplex | undefined
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
     const openServices = fiber.services as ServiceMap.ServiceMap<RO>
 
     const run = <R, E, _>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
@@ -112,7 +113,7 @@ export const fromDuplex = <RO>(
           options?.openTimeout ?
             Effect.timeoutOrElse({
               duration: options.openTimeout,
-              onTimeout: () =>
+              orElse: () =>
                 Effect.fail(
                   new Socket.SocketError({
                     reason: new Socket.SocketOpenError({ kind: "Timeout", cause: new Error("Connection timed out") })

package/src/NodeStdio.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import { systemError } from "effect/PlatformError"
 import * as Stdio from "effect/Stdio"
@@ -14,33 +15,38 @@ import { fromReadable } from "./NodeStream.ts"
 export const layer: Layer.Layer<Stdio.Stdio> = Layer.succeed(
   Stdio.Stdio,
   Stdio.make({
-    stdout: fromWritable({
-      evaluate: () => process.stdout,
-      onError: (cause) =>
-        systemError({
-          module: "Stdio",
-          method: "stdout",
-          kind: "Unknown",
-          cause
-        })
-    }),
-    stderr: fromWritable({
-      evaluate: () => process.stderr,
-      onError: (cause) =>
-        systemError({
-          module: "Stdio",
-          method: "stderr",
-          kind: "Unknown",
-          cause
-        })
-    }),
+    args: Effect.sync(() => process.argv.slice(2)),
+    stdout: (options) =>
+      fromWritable({
+        evaluate: () => process.stdout,
+        onError: (cause) =>
+          systemError({
+            module: "Stdio",
+            method: "stdout",
+            _tag: "Unknown",
+            cause
+          }),
+        endOnDone: options?.endOnDone ?? false
+      }),
+    stderr: (options) =>
+      fromWritable({
+        evaluate: () => process.stderr,
+        onError: (cause) =>
+          systemError({
+            module: "Stdio",
+            method: "stderr",
+            _tag: "Unknown",
+            cause
+          }),
+        endOnDone: options?.endOnDone ?? false
+      }),
     stdin: fromReadable({
       evaluate: () => process.stdin,
       onError: (cause) =>
         systemError({
           module: "Stdio",
           method: "stdin",
-          kind: "Unknown",
+          _tag: "Unknown",
           cause
         }),
       closeOnDone: false

package/src/NodeStream.ts

@@ -9,6 +9,7 @@ import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
 import type { SizeInput } from "effect/FileSystem"
 import { dual, type LazyArg } from "effect/Function"
+import * as Latch from "effect/Latch"
 import * as MutableRef from "effect/MutableRef"
 import * as Pull from "effect/Pull"
 import * as Scope from "effect/Scope"
@@ -301,9 +302,11 @@ const readableToPullUnsafe = <A, E>(options: {
   readonly closeOnDone?: boolean | undefined
 }) => {
   const readable = options.readable as Readable
+  if (readable.readableEnded) return Effect.succeed(Cause.done())
+
   const closeOnDone = options.closeOnDone ?? true
   const exit = options.exit ?? MutableRef.make(undefined)
-  const latch = Effect.makeLatchUnsafe(false)
+  const latch = Latch.makeUnsafe(false)
   function onReadable() {
     latch.openUnsafe()
   }
@@ -354,7 +357,7 @@ const readableToPullUnsafe = <A, E>(options: {
 }
 
 class StreamAdapter<E, R> extends Readable {
-  private readonly readLatch: Effect.Latch
+  private readonly readLatch: Latch.Latch
   private fiber: Fiber.Fiber<void, E> | undefined = undefined
 
   constructor(
@@ -362,7 +365,7 @@ class StreamAdapter<E, R> extends Readable {
     stream: Stream.Stream<Uint8Array | string, E, R>
   ) {
     super({})
-    this.readLatch = Effect.makeLatchUnsafe(false)
+    this.readLatch = Latch.makeUnsafe(false)
     this.fiber = Stream.runForEachArray(stream, (chunk) =>
       this.readLatch.whenOpen(Effect.sync(() => {
         this.readLatch.closeUnsafe()

package/src/NodeTerminal.ts

@@ -4,6 +4,7 @@
 import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
 import { badArgument, type PlatformError } from "effect/PlatformError"
 import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
@@ -52,7 +53,7 @@ export const make: (
       const queue = yield* Queue.make<Terminal.UserInput, Cause.Done>()
       const handleKeypress = (s: string | undefined, k: readline.Key) => {
         const userInput = {
-          input: s,
+          input: Option.fromUndefinedOr(s),
           key: { name: k.name ?? "", ctrl: !!k.ctrl, meta: !!k.meta, shift: !!k.shift }
         }
         Queue.offerUnsafe(queue, userInput)

package/src/internal/utils.ts

@@ -1,4 +1,4 @@
-import type { SystemError, SystemErrorKind } from "effect/PlatformError"
+import type { SystemError, SystemErrorTag } from "effect/PlatformError"
 import * as PlatformError from "effect/PlatformError"
 import type { PathLike } from "node:fs"
 
@@ -8,7 +8,7 @@ export const handleErrnoException = (module: SystemError["module"], method: stri
   err: NodeJS.ErrnoException,
   [path]: [path: PathLike | number, ...args: Array<any>]
 ): PlatformError.PlatformError => {
-  let reason: SystemErrorKind = "Unknown"
+  let reason: SystemErrorTag = "Unknown"
 
   switch (err.code) {
     case "ENOENT":
@@ -41,7 +41,7 @@ export const handleErrnoException = (module: SystemError["module"], method: stri
   }
 
   return PlatformError.systemError({
-    kind: reason,
+    _tag: reason,
     module,
     method,
     pathOrDescriptor: path as string | number,