@effect/platform-node 0.1.1 → 0.3.0

package/src/internal/fileSystem.ts

@@ -2,6 +2,7 @@ import { identity, pipe } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
+import { handleErrnoException } from "@effect/platform-node/internal/error"
 import { effectify } from "@effect/platform/Effectify"
 import * as Error from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
@@ -10,55 +11,6 @@ import * as NFS from "node:fs"
 import * as OS from "node:os"
 import * as Path from "node:path"
 
-// == errors
-
-const handleErrnoException = (method: string) =>
-  (
-    err: NodeJS.ErrnoException,
-    [path]: [path: NFS.PathLike | number, ...args: Array<any>]
-  ) => {
-    let reason: Error.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 Error.SystemError({
-      reason,
-      module: "FileSystem",
-      method,
-      pathOrDescriptor: path as string | number,
-      syscall: err.syscall,
-      message: err.message
-    })
-  }
-
 const handleBadArgument = (method: string) =>
   (err: unknown) =>
     Error.BadArgument({
@@ -72,7 +24,7 @@ const handleBadArgument = (method: string) =>
 const access = (() => {
   const nodeAccess = effectify(
     NFS.access,
-    handleErrnoException("access"),
+    handleErrnoException("FileSystem", "access"),
     handleBadArgument("access")
   )
   return (path: string, options?: FileSystem.AccessFileOptions) => {
@@ -92,7 +44,7 @@ const access = (() => {
 const copy = (() => {
   const nodeCp = effectify(
     NFS.cp,
-    handleErrnoException("copy"),
+    handleErrnoException("FileSystem", "copy"),
     handleBadArgument("copy")
   )
   return (fromPath: string, toPath: string, options?: FileSystem.CopyOptions) =>
@@ -108,7 +60,7 @@ const copy = (() => {
 const copyFile = (() => {
   const nodeCopyFile = effectify(
     NFS.copyFile,
-    handleErrnoException("copyFile"),
+    handleErrnoException("FileSystem", "copyFile"),
     handleBadArgument("copyFile")
   )
   return (fromPath: string, toPath: string) => nodeCopyFile(fromPath, toPath)
@@ -119,7 +71,7 @@ const copyFile = (() => {
 const chmod = (() => {
   const nodeChmod = effectify(
     NFS.chmod,
-    handleErrnoException("chmod"),
+    handleErrnoException("FileSystem", "chmod"),
     handleBadArgument("chmod")
   )
   return (path: string, mode: number) => nodeChmod(path, mode)
@@ -130,7 +82,7 @@ const chmod = (() => {
 const chown = (() => {
   const nodeChown = effectify(
     NFS.chown,
-    handleErrnoException("chown"),
+    handleErrnoException("FileSystem", "chown"),
     handleBadArgument("chown")
   )
   return (path: string, uid: number, gid: number) => nodeChown(path, uid, gid)
@@ -141,7 +93,7 @@ const chown = (() => {
 const link = (() => {
   const nodeLink = effectify(
     NFS.link,
-    handleErrnoException("link"),
+    handleErrnoException("FileSystem", "link"),
     handleBadArgument("link")
   )
   return (existingPath: string, newPath: string) => nodeLink(existingPath, newPath)
@@ -152,7 +104,7 @@ const link = (() => {
 const makeDirectory = (() => {
   const nodeMkdir = effectify(
     NFS.mkdir,
-    handleErrnoException("makeDirectory"),
+    handleErrnoException("FileSystem", "makeDirectory"),
     handleBadArgument("makeDirectory")
   )
   return (path: string, options?: FileSystem.MakeDirectoryOptions) =>
@@ -167,7 +119,7 @@ const makeDirectory = (() => {
 const makeTempDirectoryFactory = (method: string) => {
   const nodeMkdtemp = effectify(
     NFS.mkdtemp,
-    handleErrnoException(method),
+    handleErrnoException("FileSystem", method),
     handleBadArgument(method)
   )
   return (options?: FileSystem.MakeTempDirectoryOptions) =>
@@ -187,7 +139,7 @@ const makeTempDirectory = makeTempDirectoryFactory("makeTempDirectory")
 const removeFactory = (method: string) => {
   const nodeRm = effectify(
     NFS.rm,
-    handleErrnoException(method),
+    handleErrnoException("FileSystem", method),
     handleBadArgument(method)
   )
   return (path: string, options?: FileSystem.RemoveOptions) =>
@@ -217,12 +169,12 @@ const makeTempDirectoryScoped = (() => {
 const openFactory = (method: string) => {
   const nodeOpen = effectify(
     NFS.open,
-    handleErrnoException(method),
+    handleErrnoException("FileSystem", method),
     handleBadArgument(method)
   )
   const nodeClose = effectify(
     NFS.close,
-    handleErrnoException(method),
+    handleErrnoException("FileSystem", method),
     handleBadArgument(method)
   )
 
@@ -241,26 +193,26 @@ const makeFile = (() => {
   const nodeReadFactory = (method: string) =>
     effectify(
       NFS.read,
-      handleErrnoException(method),
+      handleErrnoException("FileSystem", method),
       handleBadArgument(method)
     )
   const nodeRead = nodeReadFactory("read")
   const nodeReadAlloc = nodeReadFactory("readAlloc")
   const nodeStat = effectify(
     NFS.fstat,
-    handleErrnoException("stat"),
+    handleErrnoException("FileSystem", "stat"),
     handleBadArgument("stat")
   )
   const nodeTruncate = effectify(
     NFS.ftruncate,
-    handleErrnoException("truncate"),
+    handleErrnoException("FileSystem", "truncate"),
     handleBadArgument("truncate")
   )
 
   const nodeWriteFactory = (method: string) =>
     effectify(
       NFS.write,
-      handleErrnoException(method),
+      handleErrnoException("FileSystem", method),
       handleBadArgument(method)
     )
   const nodeWrite = nodeWriteFactory("write")
@@ -341,7 +293,7 @@ const makeFile = (() => {
           } else if (bytesWritten < buffer.length) {
             return this.writeAll(buffer.subarray(bytesWritten))
           }
-          return Effect.unit()
+          return Effect.unit
         }
       )
     }
@@ -382,7 +334,7 @@ const makeTempFileScoped = (() => {
 const readDirectory = (() => {
   const nodeReadDirectory = effectify(
     NFS.readdir,
-    handleErrnoException("readDirectory"),
+    handleErrnoException("FileSystem", "readDirectory"),
     handleBadArgument("readDirectory")
   )
 
@@ -399,7 +351,7 @@ const readFile = (path: string) =>
     try {
       NFS.readFile(path, { signal: controller.signal }, (err, data) => {
         if (err) {
-          resume(Effect.fail(handleErrnoException("readFile")(err, [path])))
+          resume(Effect.fail(handleErrnoException("FileSystem", "readFile")(err, [path])))
         } else {
           resume(Effect.succeed(data))
         }
@@ -416,7 +368,7 @@ const readFile = (path: string) =>
 const readLink = (() => {
   const nodeReadLink = effectify(
     NFS.readlink,
-    handleErrnoException("readLink"),
+    handleErrnoException("FileSystem", "readLink"),
     handleBadArgument("readLink")
   )
   return (path: string) => nodeReadLink(path)
@@ -427,7 +379,7 @@ const readLink = (() => {
 const realPath = (() => {
   const nodeRealPath = effectify(
     NFS.realpath,
-    handleErrnoException("realPath"),
+    handleErrnoException("FileSystem", "realPath"),
     handleBadArgument("realPath")
   )
   return (path: string) => nodeRealPath(path)
@@ -438,7 +390,7 @@ const realPath = (() => {
 const rename = (() => {
   const nodeRename = effectify(
     NFS.rename,
-    handleErrnoException("rename"),
+    handleErrnoException("FileSystem", "rename"),
     handleBadArgument("rename")
   )
   return (oldPath: string, newPath: string) => nodeRename(oldPath, newPath)
@@ -479,7 +431,7 @@ const makeFileInfo = (stat: NFS.Stats): FileSystem.File.Info => ({
 const stat = (() => {
   const nodeStat = effectify(
     NFS.stat,
-    handleErrnoException("stat"),
+    handleErrnoException("FileSystem", "stat"),
     handleBadArgument("stat")
   )
   return (path: string) => Effect.map(nodeStat(path), makeFileInfo)
@@ -490,7 +442,7 @@ const stat = (() => {
 const symlink = (() => {
   const nodeSymlink = effectify(
     NFS.symlink,
-    handleErrnoException("symlink"),
+    handleErrnoException("FileSystem", "symlink"),
     handleBadArgument("symlink")
   )
   return (target: string, path: string) => nodeSymlink(target, path)
@@ -501,7 +453,7 @@ const symlink = (() => {
 const truncate = (() => {
   const nodeTruncate = effectify(
     NFS.truncate,
-    handleErrnoException("truncate"),
+    handleErrnoException("FileSystem", "truncate"),
     handleBadArgument("truncate")
   )
   return (path: string, length?: FileSystem.Size) => nodeTruncate(path, Number(length))
@@ -512,7 +464,7 @@ const truncate = (() => {
 const utimes = (() => {
   const nodeUtimes = effectify(
     NFS.utimes,
-    handleErrnoException("utime"),
+    handleErrnoException("FileSystem", "utime"),
     handleBadArgument("utime")
   )
   return (path: string, atime: number | Date, mtime: number | Date) => nodeUtimes(path, atime, mtime)
@@ -530,9 +482,9 @@ const writeFile = (path: string, data: Uint8Array, options?: FileSystem.WriteFil
         mode: options?.mode
       }, (err) => {
         if (err) {
-          resume(Effect.fail(handleErrnoException("writeFile")(err, [path])))
+          resume(Effect.fail(handleErrnoException("FileSystem", "writeFile")(err, [path])))
         } else {
-          resume(Effect.unit())
+          resume(Effect.unit)
         }
       })
     } catch (err) {

package/src/internal/path.ts

@@ -10,26 +10,26 @@ import * as NodeUrl from "node:url"
 export const Path = Tag<_Path>()
 
 const fromFileUrl = (url: URL): Effect.Effect<never, BadArgument, string> =>
-  Effect.tryCatch(
-    () => NodeUrl.fileURLToPath(url),
-    (error) =>
+  Effect.try({
+    try: () => NodeUrl.fileURLToPath(url),
+    catch: (error) =>
       BadArgument({
         module: "Path",
         method: "fromFileUrl",
         message: `${error}`
       })
-  )
+  })
 
 const toFileUrl = (path: string): Effect.Effect<never, BadArgument, URL> =>
-  Effect.tryCatch(
-    () => NodeUrl.pathToFileURL(path),
-    (error) =>
+  Effect.try({
+    try: () => NodeUrl.pathToFileURL(path),
+    catch: (error) =>
       BadArgument({
         module: "Path",
         method: "toFileUrl",
         message: `${error}`
       })
-  )
+  })
 
 /** @internal */
 export const layerPosix = Layer.succeed(

package/src/internal/runtime.ts

@@ -30,9 +30,9 @@ export const runMain: RunMain = <E, A>(
 }
 
 const interruptAll = (id: FiberId.FiberId) =>
-  Effect.flatMap(Fiber.roots(), (roots) => {
+  Effect.flatMap(Fiber.roots, (roots) => {
     if (roots.length === 0) {
-      return Effect.unit()
+      return Effect.unit
     }
 
     return Fiber.interruptAllAs(roots, id)

package/src/internal/sink.ts

@@ -36,11 +36,11 @@ const makeSinkWithRelease = <E, A>(
 const endWritable = (stream: Writable) =>
   Effect.async<never, never, void>((resume) => {
     if (stream.closed) {
-      resume(Effect.unit())
+      resume(Effect.unit)
       return
     }
 
-    stream.end(() => resume(Effect.unit()))
+    stream.end(() => resume(Effect.unit))
   })
 
 const write = <E, A>(stream: Writable, onError: (error: unknown) => E, encoding?: BufferEncoding) =>
@@ -50,7 +50,7 @@ const write = <E, A>(stream: Writable, onError: (error: unknown) => E, encoding?
         if (err) {
           resume(Effect.fail(onError(err)))
         } else {
-          resume(Effect.unit())
+          resume(Effect.unit)
         }
       }
 

package/src/internal/stream.ts

@@ -28,7 +28,12 @@ export const fromReadable = <E, A>(
           emit.fail(onError(err))
         })
 
-        stream.once("end", () => {
+        // The 'close' event is emitted after a process has ended and the stdio
+        // streams of a child process have been closed. This is distinct from
+        // the 'exit' event, since multiple processes might share the same
+        // stdio streams. The 'close' event will always emit after 'exit' was
+        // already emitted, or 'error' if the child failed to spawn.
+        stream.once("close", () => {
           emit.end()
         })