@effect/platform-node 0.0.0 → 0.1.1

package/src/internal/fileSystem.ts

@@ -1,11 +1,10 @@
-import { pipe } from "@effect/data/Function"
+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 { effectify } from "@effect/platform/Effectify"
 import * as Error from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
-import * as File from "@effect/platform/FileSystem/File"
 import * as Crypto from "node:crypto"
 import * as NFS from "node:fs"
 import * as OS from "node:os"
@@ -54,7 +53,7 @@ const handleErrnoException = (method: string) =>
       reason,
       module: "FileSystem",
       method,
-      pathOrDescriptor: path.toString(),
+      pathOrDescriptor: path as string | number,
       syscall: err.syscall,
       message: err.message
     })
@@ -88,6 +87,22 @@ const access = (() => {
   }
 })()
 
+// == copy
+
+const copy = (() => {
+  const nodeCp = effectify(
+    NFS.cp,
+    handleErrnoException("copy"),
+    handleBadArgument("copy")
+  )
+  return (fromPath: string, toPath: string, options?: FileSystem.CopyOptions) =>
+    nodeCp(fromPath, toPath, {
+      force: options?.overwrite ?? false,
+      preserveTimestamps: options?.preserveTimestamps ?? false,
+      recursive: true
+    })
+})()
+
 // == copyFile
 
 const copyFile = (() => {
@@ -162,7 +177,7 @@ const makeTempDirectoryFactory = (method: string) => {
         ? Path.join(options.directory, ".")
         : OS.tmpdir()
 
-      return nodeMkdtemp(prefix ? Path.join(directory, prefix) : directory)
+      return nodeMkdtemp(prefix ? Path.join(directory, prefix) : directory + "/")
     })
 }
 const makeTempDirectory = makeTempDirectoryFactory("makeTempDirectory")
@@ -175,7 +190,11 @@ const removeFactory = (method: string) => {
     handleErrnoException(method),
     handleBadArgument(method)
   )
-  return (path: string, options?: FileSystem.RemoveOptions) => nodeRm(path, { recursive: options?.recursive ?? false })
+  return (path: string, options?: FileSystem.RemoveOptions) =>
+    nodeRm(
+      path,
+      { recursive: options?.recursive ?? false }
+    )
 }
 const remove = removeFactory("remove")
 
@@ -193,31 +212,18 @@ const makeTempDirectoryScoped = (() => {
     )
 })()
 
-// == makeTempFile
-
-const makeTempFile = (() => {
-  const makeDirectory = makeTempDirectoryFactory("makeTempFile")
-  const randomHexString = (bytes: number) => Effect.sync(() => Crypto.randomBytes(bytes).toString("hex"))
-  return (options?: FileSystem.MakeTempFileOptions) =>
-    pipe(
-      Effect.zip(makeDirectory(options), randomHexString(6)),
-      Effect.map(([directory, random]) => Path.join(directory, random)),
-      Effect.flatMap((path) => open(path, { flag: "w+" }))
-    )
-})()
-
 // == open
 
-const open = (() => {
+const openFactory = (method: string) => {
   const nodeOpen = effectify(
     NFS.open,
-    handleErrnoException("open"),
-    handleBadArgument("open")
+    handleErrnoException(method),
+    handleBadArgument(method)
   )
   const nodeClose = effectify(
     NFS.close,
-    handleErrnoException("open"),
-    handleBadArgument("open")
+    handleErrnoException(method),
+    handleBadArgument(method)
   )
 
   return (path: string, options?: FileSystem.OpenFileOptions) =>
@@ -226,9 +232,10 @@ const open = (() => {
         nodeOpen(path, options?.flag ?? "r", options?.mode),
         (fd) => Effect.orDie(nodeClose(fd))
       ),
-      Effect.map((fd) => makeFile(File.Descriptor(fd)))
+      Effect.map((fd) => makeFile(FileSystem.FileDescriptor(fd)))
     )
-})()
+}
+const open = openFactory("open")
 
 const makeFile = (() => {
   const nodeReadFactory = (method: string) =>
@@ -259,11 +266,11 @@ const makeFile = (() => {
   const nodeWrite = nodeWriteFactory("write")
   const nodeWriteAll = nodeWriteFactory("writeAll")
 
-  class FileImpl {
-    readonly [File.FileTypeId] = File.FileTypeId
+  class FileImpl implements FileSystem.File {
+    readonly [FileSystem.FileTypeId] = identity
 
     constructor(
-      readonly fd: File.File.Descriptor
+      readonly fd: FileSystem.File.Descriptor
     ) {}
 
     get stat() {
@@ -272,7 +279,7 @@ const makeFile = (() => {
 
     read(
       buffer: Uint8Array,
-      options?: File.FileReadOptions
+      options?: FileSystem.FileReadOptions
     ) {
       return Effect.map(
         nodeRead(this.fd, {
@@ -284,7 +291,7 @@ const makeFile = (() => {
       )
     }
 
-    readAlloc(size: FileSystem.Size, options?: File.FileReadOptions | undefined) {
+    readAlloc(size: FileSystem.Size, options?: FileSystem.FileReadOptions | undefined) {
       return Effect.flatMap(
         Effect.sync(() => Buffer.allocUnsafeSlow(Number(size))),
         (buffer) =>
@@ -323,16 +330,51 @@ const makeFile = (() => {
       return Effect.flatMap(
         nodeWriteAll(this.fd, buffer),
         (bytesWritten) => {
-          if (bytesWritten === buffer.length) {
-            return Effect.unit()
+          if (bytesWritten === 0) {
+            return Effect.fail(Error.SystemError({
+              module: "FileSystem",
+              method: "writeAll",
+              reason: "WriteZero",
+              pathOrDescriptor: this.fd,
+              message: "write returned 0 bytes written"
+            }))
+          } else if (bytesWritten < buffer.length) {
+            return this.writeAll(buffer.subarray(bytesWritten))
           }
-          return this.writeAll(buffer.subarray(bytesWritten))
+          return Effect.unit()
         }
       )
     }
   }
 
-  return (fd: File.File.Descriptor) => new FileImpl(fd) as File.File
+  return (fd: FileSystem.File.Descriptor): FileSystem.File => new FileImpl(fd)
+})()
+
+// == makeTempFile
+
+const makeTempFileFactory = (method: string) => {
+  const makeDirectory = makeTempDirectoryFactory(method)
+  const open = openFactory(method)
+  const randomHexString = (bytes: number) => Effect.sync(() => Crypto.randomBytes(bytes).toString("hex"))
+  return (options?: FileSystem.MakeTempFileOptions) =>
+    pipe(
+      Effect.zip(makeDirectory(options), randomHexString(6)),
+      Effect.map(([directory, random]) => Path.join(directory, random)),
+      Effect.tap((path) => Effect.scoped(open(path, { flag: "w+" })))
+    )
+}
+const makeTempFile = makeTempFileFactory("makeTempFile")
+
+// == makeTempFileScoped
+
+const makeTempFileScoped = (() => {
+  const makeFile = makeTempFileFactory("makeTempFileScoped")
+  const removeFile = removeFactory("makeTempFileScoped")
+  return (options?: FileSystem.MakeTempFileOptions) =>
+    Effect.acquireRelease(
+      makeFile(options),
+      (file) => Effect.orDie(removeFile(file))
+    )
 })()
 
 // == readDirectory
@@ -404,7 +446,7 @@ const rename = (() => {
 
 // == stat
 
-const makeFileInfo = (stat: NFS.Stats): File.File.Info => ({
+const makeFileInfo = (stat: NFS.Stats): FileSystem.File.Info => ({
   type: stat.isFile() ?
     "File" :
     stat.isDirectory() ?
@@ -465,15 +507,15 @@ const truncate = (() => {
   return (path: string, length?: FileSystem.Size) => nodeTruncate(path, Number(length))
 })()
 
-// == utime
+// == utimes
 
-const utime = (() => {
-  const nodeUtime = effectify(
+const utimes = (() => {
+  const nodeUtimes = effectify(
     NFS.utimes,
     handleErrnoException("utime"),
     handleBadArgument("utime")
   )
-  return (path: string, atime: number | Date, mtime: number | Date) => nodeUtime(path, atime, mtime)
+  return (path: string, atime: number | Date, mtime: number | Date) => nodeUtimes(path, atime, mtime)
 })()
 
 // == writeFile
@@ -501,14 +543,16 @@ const writeFile = (path: string, data: Uint8Array, options?: FileSystem.WriteFil
 
 const fileSystemImpl = FileSystem.make({
   access,
-  copyFile,
   chmod,
   chown,
+  copy,
+  copyFile,
   link,
   makeDirectory,
   makeTempDirectory,
   makeTempDirectoryScoped,
   makeTempFile,
+  makeTempFileScoped,
   open,
   readDirectory,
   readFile,
@@ -519,7 +563,7 @@ const fileSystemImpl = FileSystem.make({
   stat,
   symlink,
   truncate,
-  utime,
+  utimes,
   writeFile
 })
 

package/src/internal/path.ts

@@ -0,0 +1,62 @@
+import { Tag } from "@effect/data/Context"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import { BadArgument } from "@effect/platform/Error"
+import type { Path as _Path } from "@effect/platform/Path"
+import * as NodePath from "node:path"
+import * as NodeUrl from "node:url"
+
+/** @internal */
+export const Path = Tag<_Path>()
+
+const fromFileUrl = (url: URL): Effect.Effect<never, BadArgument, string> =>
+  Effect.tryCatch(
+    () => NodeUrl.fileURLToPath(url),
+    (error) =>
+      BadArgument({
+        module: "Path",
+        method: "fromFileUrl",
+        message: `${error}`
+      })
+  )
+
+const toFileUrl = (path: string): Effect.Effect<never, BadArgument, URL> =>
+  Effect.tryCatch(
+    () => NodeUrl.pathToFileURL(path),
+    (error) =>
+      BadArgument({
+        module: "Path",
+        method: "toFileUrl",
+        message: `${error}`
+      })
+  )
+
+/** @internal */
+export const layerPosix = Layer.succeed(
+  Path,
+  Path.of({
+    ...NodePath.posix,
+    fromFileUrl,
+    toFileUrl
+  })
+)
+
+/** @internal */
+export const layerWin32 = Layer.succeed(
+  Path,
+  Path.of({
+    ...NodePath.win32,
+    fromFileUrl,
+    toFileUrl
+  })
+)
+
+/** @internal */
+export const layer = Layer.succeed(
+  Path,
+  Path.of({
+    ...NodePath,
+    fromFileUrl,
+    toFileUrl
+  })
+)

package/src/internal/stream.ts

@@ -3,17 +3,15 @@ import { pipe } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import type { FromReadableOptions } from "@effect/platform-node/Stream"
-import { Size } from "@effect/platform/FileSystem"
+import type { Size } from "@effect/platform/FileSystem"
 import * as Stream from "@effect/stream/Stream"
 import type { Readable } from "node:stream"
 
-const DEFAULT_CHUNK_SIZE = Size(64 * 1024)
-
 /** @internal */
 export const fromReadable = <E, A>(
   evaluate: LazyArg<Readable>,
   onError: (error: unknown) => E,
-  { chunkSize = DEFAULT_CHUNK_SIZE }: FromReadableOptions = {}
+  { chunkSize = Option.none() }: FromReadableOptions = {}
 ): Stream.Stream<never, E, A> =>
   pipe(
     Effect.acquireRelease(Effect.sync(evaluate), (stream) =>
@@ -49,9 +47,9 @@ export const fromReadable = <E, A>(
 
 const readChunk = <A>(
   stream: Readable,
-  size: Size
+  size: Option.Option<Size>
 ): Effect.Effect<never, Option.Option<never>, A> =>
   pipe(
-    Effect.sync(() => stream.read(Number(size)) as A | null),
-    Effect.flatMap((a) => (a ? Effect.succeed(a) : Effect.fail(Option.none())))
+    Effect.sync(() => (size._tag === "Some" ? stream.read(Number(size)) : stream.read()) as A | null),
+    Effect.flatMap((_) => (_ ? Effect.succeed(_) : Effect.fail(Option.none())))
   )