effect-start 0.25.0 → 0.26.0

package/dist/node/NodeFileSystem.js

@@ -1,675 +0,0 @@
-/*
- * Adapted from @effect/platform
- */
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as FileSystem from "../FileSystem.js"
-import * as Stream from "effect/Stream"
-import * as NCrypto from "node:crypto"
-import * as NFS from "node:fs"
-import * as NOS from "node:os"
-import * as NPath from "node:path"
-import * as PlatformError from "../PlatformError.js"
-import * as Effectify from "../Effectify.js"
-
-const handleBadArgument = (method) => (cause) =>
-  new PlatformError.BadArgument({
-    module: "FileSystem",
-    method,
-    cause,
-  })
-
-const access = (() => {
-  const nodeAccess = Effectify.effectify(
-    NFS.access,
-    handleErrnoException("FileSystem", "access"),
-    handleBadArgument("access"),
-  )
-  return (path, options) => {
-    let mode = NFS.constants.F_OK
-    if (options?.readable) {
-      mode |= NFS.constants.R_OK
-    }
-    if (options?.writable) {
-      mode |= NFS.constants.W_OK
-    }
-    return nodeAccess(path, mode)
-  }
-})()
-
-const copy = (() => {
-  const nodeCp = Effectify.effectify(
-    NFS.cp,
-    handleErrnoException("FileSystem", "copy"),
-    handleBadArgument("copy"),
-  )
-  return (fromPath, toPath, options) =>
-    nodeCp(fromPath, toPath, {
-      force: options?.overwrite ?? false,
-      preserveTimestamps: options?.preserveTimestamps ?? false,
-      recursive: true,
-    })
-})()
-
-const copyFile = (() => {
-  const nodeCopyFile = Effectify.effectify(
-    NFS.copyFile,
-    handleErrnoException("FileSystem", "copyFile"),
-    handleBadArgument("copyFile"),
-  )
-  return (fromPath, toPath) => nodeCopyFile(fromPath, toPath)
-})()
-
-const chmod = (() => {
-  const nodeChmod = Effectify.effectify(
-    NFS.chmod,
-    handleErrnoException("FileSystem", "chmod"),
-    handleBadArgument("chmod"),
-  )
-  return (path, mode) => nodeChmod(path, mode)
-})()
-
-const chown = (() => {
-  const nodeChown = Effectify.effectify(
-    NFS.chown,
-    handleErrnoException("FileSystem", "chown"),
-    handleBadArgument("chown"),
-  )
-  return (path, uid, gid) => nodeChown(path, uid, gid)
-})()
-
-const link = (() => {
-  const nodeLink = Effectify.effectify(
-    NFS.link,
-    handleErrnoException("FileSystem", "link"),
-    handleBadArgument("link"),
-  )
-  return (existingPath, newPath) => nodeLink(existingPath, newPath)
-})()
-
-const makeDirectory = (() => {
-  const nodeMkdir = Effectify.effectify(
-    NFS.mkdir,
-    handleErrnoException("FileSystem", "makeDirectory"),
-    handleBadArgument("makeDirectory"),
-  )
-  return (path, options) =>
-    nodeMkdir(path, {
-      recursive: options?.recursive ?? false,
-      mode: options?.mode,
-    })
-})()
-
-const makeTempDirectoryFactory = (method) => {
-  const nodeMkdtemp = Effectify.effectify(
-    NFS.mkdtemp,
-    handleErrnoException("FileSystem", method),
-    handleBadArgument(method),
-  )
-  return (options) =>
-    Effect.suspend(() => {
-      const prefix = options?.prefix ?? ""
-      const directory =
-        typeof options?.directory === "string" ? NPath.join(options.directory, ".") : NOS.tmpdir()
-
-      return nodeMkdtemp(prefix ? NPath.join(directory, prefix) : directory + "/")
-    })
-}
-const makeTempDirectory = makeTempDirectoryFactory("makeTempDirectory")
-
-const removeFactory = (method) => {
-  const nodeRm = Effectify.effectify(
-    NFS.rm,
-    handleErrnoException("FileSystem", method),
-    handleBadArgument(method),
-  )
-  return (path, options) =>
-    nodeRm(path, {
-      recursive: options?.recursive ?? false,
-      force: options?.force ?? false,
-    })
-}
-const remove = removeFactory("remove")
-
-const makeTempDirectoryScoped = (() => {
-  const makeDirectory = makeTempDirectoryFactory("makeTempDirectoryScoped")
-  const removeDirectory = removeFactory("makeTempDirectoryScoped")
-  return (options) =>
-    Effect.acquireRelease(makeDirectory(options), (directory) =>
-      Effect.orDie(removeDirectory(directory, { recursive: true })),
-    )
-})()
-
-const openFactory = (method) => {
-  const nodeOpen = Effectify.effectify(
-    NFS.open,
-    handleErrnoException("FileSystem", method),
-    handleBadArgument(method),
-  )
-  const nodeClose = Effectify.effectify(
-    NFS.close,
-    handleErrnoException("FileSystem", method),
-    handleBadArgument(method),
-  )
-
-  return (path, options) =>
-    Function.pipe(
-      Effect.acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) =>
-        Effect.orDie(nodeClose(fd)),
-      ),
-      Effect.map((fd) =>
-        makeFile(FileSystem.FileDescriptor(fd), options?.flag?.startsWith("a") ?? false),
-      ),
-    )
-}
-const open = openFactory("open")
-
-const makeFile = (() => {
-  const nodeReadFactory = (method) =>
-    Effectify.effectify(
-      NFS.read,
-      handleErrnoException("FileSystem", method),
-      handleBadArgument(method),
-    )
-  const nodeRead = nodeReadFactory("read")
-  const nodeReadAlloc = nodeReadFactory("readAlloc")
-  const nodeStat = Effectify.effectify(
-    NFS.fstat,
-    handleErrnoException("FileSystem", "stat"),
-    handleBadArgument("stat"),
-  )
-  const nodeTruncate = Effectify.effectify(
-    NFS.ftruncate,
-    handleErrnoException("FileSystem", "truncate"),
-    handleBadArgument("truncate"),
-  )
-
-  const nodeSync = Effectify.effectify(
-    NFS.fsync,
-    handleErrnoException("FileSystem", "sync"),
-    handleBadArgument("sync"),
-  )
-
-  const nodeWriteFactory = (method) =>
-    Effectify.effectify(
-      NFS.write,
-      handleErrnoException("FileSystem", method),
-      handleBadArgument(method),
-    )
-  const nodeWrite = nodeWriteFactory("write")
-  const nodeWriteAll = nodeWriteFactory("writeAll")
-
-  class FileImpl {
-    [FileSystem.FileTypeId]
-    fd
-    append
-
-    semaphore = Effect.unsafeMakeSemaphore(1)
-    position = 0n
-
-    constructor(fd, append) {
-      this[FileSystem.FileTypeId] = FileSystem.FileTypeId
-      this.fd = fd
-      this.append = append
-    }
-
-    get stat() {
-      return Effect.map(nodeStat(this.fd), makeFileInfo)
-    }
-
-    get sync() {
-      return nodeSync(this.fd)
-    }
-
-    seek(offset, from) {
-      const offsetSize = FileSystem.Size(offset)
-      return this.semaphore.withPermits(1)(
-        Effect.sync(() => {
-          if (from === "start") {
-            this.position = offsetSize
-          } else if (from === "current") {
-            this.position = this.position + offsetSize
-          }
-
-          return this.position
-        }),
-      )
-    }
-
-    read(buffer) {
-      return this.semaphore.withPermits(1)(
-        Effect.map(
-          Effect.suspend(() =>
-            nodeRead(this.fd, {
-              buffer,
-              position: this.position,
-            }),
-          ),
-          (bytesRead) => {
-            const sizeRead = FileSystem.Size(bytesRead)
-            this.position = this.position + sizeRead
-            return sizeRead
-          },
-        ),
-      )
-    }
-
-    readAlloc(size) {
-      const sizeNumber = Number(size)
-      return this.semaphore.withPermits(1)(
-        Effect.flatMap(
-          Effect.sync(() => Buffer.allocUnsafeSlow(sizeNumber)),
-          (buffer) =>
-            Effect.map(
-              nodeReadAlloc(this.fd, {
-                buffer,
-                position: this.position,
-              }),
-              (bytesRead) => {
-                if (bytesRead === 0) {
-                  return Option.none()
-                }
-
-                this.position = this.position + BigInt(bytesRead)
-                if (bytesRead === sizeNumber) {
-                  return Option.some(buffer)
-                }
-
-                const dst = Buffer.allocUnsafeSlow(bytesRead)
-                buffer.copy(dst, 0, 0, bytesRead)
-                return Option.some(dst)
-              },
-            ),
-        ),
-      )
-    }
-
-    truncate(length) {
-      return this.semaphore.withPermits(1)(
-        Effect.map(nodeTruncate(this.fd, length ? Number(length) : undefined), () => {
-          if (!this.append) {
-            const len = BigInt(length ?? 0)
-            if (this.position > len) {
-              this.position = len
-            }
-          }
-        }),
-      )
-    }
-
-    write(buffer) {
-      return this.semaphore.withPermits(1)(
-        Effect.map(
-          Effect.suspend(() =>
-            nodeWrite(
-              this.fd,
-              buffer,
-              undefined,
-              undefined,
-              this.append ? undefined : Number(this.position),
-            ),
-          ),
-          (bytesWritten) => {
-            const sizeWritten = FileSystem.Size(bytesWritten)
-            if (!this.append) {
-              this.position = this.position + sizeWritten
-            }
-
-            return sizeWritten
-          },
-        ),
-      )
-    }
-
-    writeAllChunk(buffer) {
-      return Effect.flatMap(
-        Effect.suspend(() =>
-          nodeWriteAll(
-            this.fd,
-            buffer,
-            undefined,
-            undefined,
-            this.append ? undefined : Number(this.position),
-          ),
-        ),
-        (bytesWritten) => {
-          if (bytesWritten === 0) {
-            return Effect.fail(
-              new PlatformError.SystemError({
-                module: "FileSystem",
-                method: "writeAll",
-                reason: "WriteZero",
-                pathOrDescriptor: this.fd,
-                description: "write returned 0 bytes written",
-              }),
-            )
-          }
-
-          if (!this.append) {
-            this.position = this.position + BigInt(bytesWritten)
-          }
-
-          return bytesWritten < buffer.length
-            ? this.writeAllChunk(buffer.subarray(bytesWritten))
-            : Effect.void
-        },
-      )
-    }
-
-    writeAll(buffer) {
-      return this.semaphore.withPermits(1)(this.writeAllChunk(buffer))
-    }
-  }
-
-  return (fd, append) =>
-    new FileImpl(fd, append)
-})()
-
-const makeTempFileFactory = (method) => {
-  const makeDirectory = makeTempDirectoryFactory(method)
-  const open = openFactory(method)
-  const randomHexString = (bytes) =>
-    Effect.sync(() => NCrypto.randomBytes(bytes).toString("hex"))
-  return (options) =>
-    Function.pipe(
-      Effect.zip(makeDirectory(options), randomHexString(6)),
-      Effect.map(([directory, random]) => NPath.join(directory, random + (options?.suffix ?? ""))),
-      Effect.tap((path) => Effect.scoped(open(path, { flag: "w+" }))),
-    )
-}
-const makeTempFile = makeTempFileFactory("makeTempFile")
-
-const makeTempFileScoped = (() => {
-  const makeFile = makeTempFileFactory("makeTempFileScoped")
-  const removeDirectory = removeFactory("makeTempFileScoped")
-  return (options) =>
-    Effect.acquireRelease(makeFile(options), (file) =>
-      Effect.orDie(removeDirectory(NPath.dirname(file), { recursive: true })),
-    )
-})()
-
-const readDirectory = (path, options) =>
-  Effect.tryPromise({
-    try: () => NFS.promises.readdir(path, options),
-    catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path]),
-  })
-
-const readFile = (path) =>
-  Effect.async((resume, signal) => {
-    try {
-      NFS.readFile(path, { signal }, (err, data) => {
-        if (err) {
-          resume(Effect.fail(handleErrnoException("FileSystem", "readFile")(err, [path])))
-        } else {
-          resume(Effect.succeed(data))
-        }
-      })
-    } catch (err) {
-      resume(Effect.fail(handleBadArgument("readFile")(err)))
-    }
-  })
-
-const readLink = (() => {
-  const nodeReadLink = Effectify.effectify(
-    NFS.readlink,
-    handleErrnoException("FileSystem", "readLink"),
-    handleBadArgument("readLink"),
-  )
-  return (path) => nodeReadLink(path)
-})()
-
-const realPath = (() => {
-  const nodeRealPath = Effectify.effectify(
-    NFS.realpath,
-    handleErrnoException("FileSystem", "realPath"),
-    handleBadArgument("realPath"),
-  )
-  return (path) => nodeRealPath(path)
-})()
-
-const rename = (() => {
-  const nodeRename = Effectify.effectify(
-    NFS.rename,
-    handleErrnoException("FileSystem", "rename"),
-    handleBadArgument("rename"),
-  )
-  return (oldPath, newPath) => nodeRename(oldPath, newPath)
-})()
-
-const makeFileInfo = (stat) => ({
-  type: stat.isFile()
-    ? "File"
-    : stat.isDirectory()
-      ? "Directory"
-      : stat.isSymbolicLink()
-        ? "SymbolicLink"
-        : stat.isBlockDevice()
-          ? "BlockDevice"
-          : stat.isCharacterDevice()
-            ? "CharacterDevice"
-            : stat.isFIFO()
-              ? "FIFO"
-              : stat.isSocket()
-                ? "Socket"
-                : "Unknown",
-  mtime: Option.fromNullable(stat.mtime),
-  atime: Option.fromNullable(stat.atime),
-  birthtime: Option.fromNullable(stat.birthtime),
-  dev: stat.dev,
-  rdev: Option.fromNullable(stat.rdev),
-  ino: Option.fromNullable(stat.ino),
-  mode: stat.mode,
-  nlink: Option.fromNullable(stat.nlink),
-  uid: Option.fromNullable(stat.uid),
-  gid: Option.fromNullable(stat.gid),
-  size: FileSystem.Size(stat.size),
-  blksize: Option.map(Option.fromNullable(stat.blksize), FileSystem.Size),
-  blocks: Option.fromNullable(stat.blocks),
-})
-const stat = (() => {
-  const nodeStat = Effectify.effectify(
-    NFS.stat,
-    handleErrnoException("FileSystem", "stat"),
-    handleBadArgument("stat"),
-  )
-  return (path) => Effect.map(nodeStat(path), makeFileInfo)
-})()
-
-const symlink = (() => {
-  const nodeSymlink = Effectify.effectify(
-    NFS.symlink,
-    handleErrnoException("FileSystem", "symlink"),
-    handleBadArgument("symlink"),
-  )
-  return (target, path) => nodeSymlink(target, path)
-})()
-
-const truncate = (() => {
-  const nodeTruncate = Effectify.effectify(
-    NFS.truncate,
-    handleErrnoException("FileSystem", "truncate"),
-    handleBadArgument("truncate"),
-  )
-  return (path, length) =>
-    nodeTruncate(path, length !== undefined ? Number(length) : undefined)
-})()
-
-const utimes = (() => {
-  const nodeUtimes = Effectify.effectify(
-    NFS.utimes,
-    handleErrnoException("FileSystem", "utime"),
-    handleBadArgument("utime"),
-  )
-  return (path, atime, mtime) =>
-    nodeUtimes(path, atime, mtime)
-})()
-
-const watchNode = (path, options) =>
-  Stream.asyncScoped((emit) =>
-    Effect.acquireRelease(
-      Effect.sync(() => {
-        const watcher = NFS.watch(path, { recursive: options?.recursive }, (event, path) => {
-          if (!path) return
-          switch (event) {
-            case "rename": {
-              emit.fromEffect(
-                Effect.matchEffect(stat(path), {
-                  onSuccess: (_) => Effect.succeed(FileSystem.WatchEventCreate({ path })),
-                  onFailure: (err) =>
-                    err._tag === "SystemError" && err.reason === "NotFound"
-                      ? Effect.succeed(FileSystem.WatchEventRemove({ path }))
-                      : Effect.fail(err),
-                }),
-              )
-              return
-            }
-            case "change": {
-              emit.single(FileSystem.WatchEventUpdate({ path }))
-              return
-            }
-          }
-        })
-        watcher.on("error", (error) => {
-          emit.fail(
-            new PlatformError.SystemError({
-              module: "FileSystem",
-              reason: "Unknown",
-              method: "watch",
-              pathOrDescriptor: path,
-              cause: error,
-            }),
-          )
-        })
-        watcher.on("close", () => {
-          emit.end()
-        })
-        return watcher
-      }),
-      (watcher) => Effect.sync(() => watcher.close()),
-    ),
-  )
-
-const watch = (
-  backend,
-  path,
-  options,
-) =>
-  stat(path).pipe(
-    Effect.map((stat) =>
-      backend.pipe(
-        Option.flatMap((_) => _.register(path, stat, options)),
-        Option.getOrElse(() => watchNode(path, options)),
-      ),
-    ),
-    Stream.unwrap,
-  )
-
-const writeFile = (path, data, options) =>
-  Effect.async((resume, signal) => {
-    try {
-      NFS.writeFile(
-        path,
-        data,
-        {
-          signal,
-          flag: options?.flag,
-          mode: options?.mode,
-        },
-        (err) => {
-          if (err) {
-            resume(Effect.fail(handleErrnoException("FileSystem", "writeFile")(err, [path])))
-          } else {
-            resume(Effect.void)
-          }
-        },
-      )
-    } catch (err) {
-      resume(Effect.fail(handleBadArgument("writeFile")(err)))
-    }
-  })
-
-const make = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend) =>
-  FileSystem.make({
-    access,
-    chmod,
-    chown,
-    copy,
-    copyFile,
-    link,
-    makeDirectory,
-    makeTempDirectory,
-    makeTempDirectoryScoped,
-    makeTempFile,
-    makeTempFileScoped,
-    open,
-    readDirectory,
-    readFile,
-    readLink,
-    realPath,
-    remove,
-    rename,
-    stat,
-    symlink,
-    truncate,
-    utimes,
-    watch(path, options) {
-      return watch(backend, path, options)
-    },
-    writeFile,
-  }),
-)
-
-export const layer = Layer.effect(FileSystem.FileSystem, make)
-
-export { PlatformError as Error }
-
-export function handleErrnoException(module, method) {
-  return function (
-    err,
-    [path],
-  ) {
-    let reason = "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 new PlatformError.SystemError({
-      reason,
-      module,
-      method,
-      pathOrDescriptor: path,
-      syscall: err.syscall,
-      description: err.message,
-      cause: err,
-    })
-  }
-}

package/dist/node/NodeUtils.js

@@ -1,23 +0,0 @@
-import * as NFS from "node:fs/promises"
-import * as NPath from "node:path"
-
-export const getEntrypoint = () => NPath.dirname(process.argv[1])
-
-export const findClosestPackageJson = async (path) => {
-  const resolved = NPath.resolve(path)
-  const stat = await NFS.stat(resolved).catch(() => undefined)
-  let dir = stat?.isDirectory() ? resolved : NPath.dirname(resolved)
-  const root = NPath.parse(dir).root
-
-  while (dir !== root) {
-    const candidate = NPath.join(dir, "package.json")
-    try {
-      await NFS.access(candidate)
-      return candidate
-    } catch {
-      dir = NPath.dirname(dir)
-    }
-  }
-
-  return undefined
-}

package/dist/sql/Sql.js

@@ -1,8 +0,0 @@
-import * as Context from "effect/Context"
-import * as Data from "effect/Data"
-
-export class SqlError extends Data.TaggedError("SqlError") {}
-
-export const SqlClient = Context.GenericTag(
-  "effect-start/Sql/SqlClient",
-)