effect-start 0.18.0 → 0.20.0

package/dist/node/FileSystem.d.ts

@@ -1,9 +1,7 @@
-import * as Error from "@effect/platform/Error";
-import type { PlatformError } from "@effect/platform/Error";
-import { SystemError } from "@effect/platform/Error";
 import * as FileSystem from "@effect/platform/FileSystem";
 import * as Layer from "effect/Layer";
 import * as NFS from "node:fs";
+import * as PlatformError from "./PlatformError.ts";
 export declare const layer: Layer.Layer<FileSystem.FileSystem, never, never>;
-export { Error, FileSystem, };
-export declare function handleErrnoException(module: SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError;
+export { FileSystem, PlatformError as Error, };
+export declare function handleErrnoException(module: PlatformError.SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError.PlatformError;

package/dist/node/FileSystem.js

@@ -1,27 +1,25 @@
 /*
  * Adapted from @effect/platform
  */
-import { effectify } from "@effect/platform/Effectify";
-import * as Error from "@effect/platform/Error";
-import { SystemError } from "@effect/platform/Error";
 import * as FileSystem from "@effect/platform/FileSystem";
 import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
+import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import * as Crypto from "node:crypto";
+import * as NCrypto from "node:crypto";
 import * as NFS from "node:fs";
 import * as NOS from "node:os";
 import * as NPath from "node:path";
-const handleBadArgument = (method) => (cause) => new Error.BadArgument({
+import * as Effectify from "./Effectify.js";
+import * as PlatformError from "./PlatformError.js";
+const handleBadArgument = (method) => (cause) => new PlatformError.BadArgument({
     module: "FileSystem",
     method,
     cause,
 });
-// == access
 const access = (() => {
-    const nodeAccess = effectify(NFS.access, handleErrnoException("FileSystem", "access"), handleBadArgument("access"));
+    const nodeAccess = Effectify.effectify(NFS.access, handleErrnoException("FileSystem", "access"), handleBadArgument("access"));
     return (path, options) => {
         let mode = NFS.constants.F_OK;
         if (options?.readable) {
@@ -33,46 +31,39 @@ const access = (() => {
         return nodeAccess(path, mode);
     };
 })();
-// == copy
 const copy = (() => {
-    const nodeCp = effectify(NFS.cp, handleErrnoException("FileSystem", "copy"), handleBadArgument("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,
     });
 })();
-// == copyFile
 const copyFile = (() => {
-    const nodeCopyFile = effectify(NFS.copyFile, handleErrnoException("FileSystem", "copyFile"), handleBadArgument("copyFile"));
+    const nodeCopyFile = Effectify.effectify(NFS.copyFile, handleErrnoException("FileSystem", "copyFile"), handleBadArgument("copyFile"));
     return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
 })();
-// == chmod
 const chmod = (() => {
-    const nodeChmod = effectify(NFS.chmod, handleErrnoException("FileSystem", "chmod"), handleBadArgument("chmod"));
+    const nodeChmod = Effectify.effectify(NFS.chmod, handleErrnoException("FileSystem", "chmod"), handleBadArgument("chmod"));
     return (path, mode) => nodeChmod(path, mode);
 })();
-// == chown
 const chown = (() => {
-    const nodeChown = effectify(NFS.chown, handleErrnoException("FileSystem", "chown"), handleBadArgument("chown"));
+    const nodeChown = Effectify.effectify(NFS.chown, handleErrnoException("FileSystem", "chown"), handleBadArgument("chown"));
     return (path, uid, gid) => nodeChown(path, uid, gid);
 })();
-// == link
 const link = (() => {
-    const nodeLink = effectify(NFS.link, handleErrnoException("FileSystem", "link"), handleBadArgument("link"));
+    const nodeLink = Effectify.effectify(NFS.link, handleErrnoException("FileSystem", "link"), handleBadArgument("link"));
     return (existingPath, newPath) => nodeLink(existingPath, newPath);
 })();
-// == makeDirectory
 const makeDirectory = (() => {
-    const nodeMkdir = effectify(NFS.mkdir, handleErrnoException("FileSystem", "makeDirectory"), handleBadArgument("makeDirectory"));
+    const nodeMkdir = Effectify.effectify(NFS.mkdir, handleErrnoException("FileSystem", "makeDirectory"), handleBadArgument("makeDirectory"));
     return (path, options) => nodeMkdir(path, {
         recursive: options?.recursive ?? false,
         mode: options?.mode,
     });
 })();
-// == makeTempDirectory
 const makeTempDirectoryFactory = (method) => {
-    const nodeMkdtemp = effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(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"
@@ -82,36 +73,33 @@ const makeTempDirectoryFactory = (method) => {
     });
 };
 const makeTempDirectory = makeTempDirectoryFactory("makeTempDirectory");
-// == remove
 const removeFactory = (method) => {
-    const nodeRm = effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(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");
-// == makeTempDirectoryScoped
 const makeTempDirectoryScoped = (() => {
     const makeDirectory = makeTempDirectoryFactory("makeTempDirectoryScoped");
     const removeDirectory = removeFactory("makeTempDirectoryScoped");
     return (options) => Effect.acquireRelease(makeDirectory(options), (directory) => Effect.orDie(removeDirectory(directory, { recursive: true })));
 })();
-// == open
 const openFactory = (method) => {
-    const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
-    const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
-    return (path, options) => 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 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(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    const nodeReadFactory = (method) => Effectify.effectify(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
     const nodeRead = nodeReadFactory("read");
     const nodeReadAlloc = nodeReadFactory("readAlloc");
-    const nodeStat = effectify(NFS.fstat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
-    const nodeTruncate = effectify(NFS.ftruncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
-    const nodeSync = effectify(NFS.fsync, handleErrnoException("FileSystem", "sync"), handleBadArgument("sync"));
-    const nodeWriteFactory = (method) => effectify(NFS.write, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    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 {
@@ -193,7 +181,7 @@ const makeFile = (() => {
         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 Error.SystemError({
+                    return Effect.fail(new PlatformError.SystemError({
                         module: "FileSystem",
                         method: "writeAll",
                         reason: "WriteZero",
@@ -215,26 +203,22 @@ const makeFile = (() => {
     }
     return (fd, append) => new FileImpl(fd, append);
 })();
-// == makeTempFile
 const makeTempFileFactory = (method) => {
     const makeDirectory = makeTempDirectoryFactory(method);
     const open = openFactory(method);
-    const randomHexString = (bytes) => Effect.sync(() => Crypto.randomBytes(bytes).toString("hex"));
-    return (options) => 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 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");
-// == makeTempFileScoped
 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 })));
 })();
-// == readDirectory
 const readDirectory = (path, options) => Effect.tryPromise({
     try: () => NFS.promises.readdir(path, options),
     catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path]),
 });
-// == readFile
 const readFile = (path) => Effect.async((resume, signal) => {
     try {
         NFS.readFile(path, { signal }, (err, data) => {
@@ -250,22 +234,18 @@ const readFile = (path) => Effect.async((resume, signal) => {
         resume(Effect.fail(handleBadArgument("readFile")(err)));
     }
 });
-// == readLink
 const readLink = (() => {
-    const nodeReadLink = effectify(NFS.readlink, handleErrnoException("FileSystem", "readLink"), handleBadArgument("readLink"));
+    const nodeReadLink = Effectify.effectify(NFS.readlink, handleErrnoException("FileSystem", "readLink"), handleBadArgument("readLink"));
     return (path) => nodeReadLink(path);
 })();
-// == realPath
 const realPath = (() => {
-    const nodeRealPath = effectify(NFS.realpath, handleErrnoException("FileSystem", "realPath"), handleBadArgument("realPath"));
+    const nodeRealPath = Effectify.effectify(NFS.realpath, handleErrnoException("FileSystem", "realPath"), handleBadArgument("realPath"));
     return (path) => nodeRealPath(path);
 })();
-// == rename
 const rename = (() => {
-    const nodeRename = effectify(NFS.rename, handleErrnoException("FileSystem", "rename"), handleBadArgument("rename"));
+    const nodeRename = Effectify.effectify(NFS.rename, handleErrnoException("FileSystem", "rename"), handleBadArgument("rename"));
     return (oldPath, newPath) => nodeRename(oldPath, newPath);
 })();
-// == stat
 const makeFileInfo = (stat) => ({
     type: stat.isFile()
         ? "File"
@@ -297,25 +277,21 @@ const makeFileInfo = (stat) => ({
     blocks: Option.fromNullable(stat.blocks),
 });
 const stat = (() => {
-    const nodeStat = effectify(NFS.stat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
+    const nodeStat = Effectify.effectify(NFS.stat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
     return (path) => Effect.map(nodeStat(path), makeFileInfo);
 })();
-// == symlink
 const symlink = (() => {
-    const nodeSymlink = effectify(NFS.symlink, handleErrnoException("FileSystem", "symlink"), handleBadArgument("symlink"));
+    const nodeSymlink = Effectify.effectify(NFS.symlink, handleErrnoException("FileSystem", "symlink"), handleBadArgument("symlink"));
     return (target, path) => nodeSymlink(target, path);
 })();
-// == truncate
 const truncate = (() => {
-    const nodeTruncate = effectify(NFS.truncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
+    const nodeTruncate = Effectify.effectify(NFS.truncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
     return (path, length) => nodeTruncate(path, length !== undefined ? Number(length) : undefined);
 })();
-// == utimes
 const utimes = (() => {
-    const nodeUtimes = effectify(NFS.utimes, handleErrnoException("FileSystem", "utime"), handleBadArgument("utime"));
+    const nodeUtimes = Effectify.effectify(NFS.utimes, handleErrnoException("FileSystem", "utime"), handleBadArgument("utime"));
     return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
 })();
-// == watch
 const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquireRelease(Effect.sync(() => {
     const watcher = NFS.watch(path, { recursive: options?.recursive }, (event, path) => {
         if (!path)
@@ -337,7 +313,7 @@ const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquire
         }
     });
     watcher.on("error", (error) => {
-        emit.fail(new Error.SystemError({
+        emit.fail(new PlatformError.SystemError({
             module: "FileSystem",
             reason: "Unknown",
             method: "watch",
@@ -351,7 +327,6 @@ const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquire
     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);
-// == writeFile
 const writeFile = (path, data, options) => Effect.async((resume, signal) => {
     try {
         NFS.writeFile(path, data, {
@@ -371,7 +346,7 @@ const writeFile = (path, data, options) => Effect.async((resume, signal) => {
         resume(Effect.fail(handleBadArgument("writeFile")(err)));
     }
 });
-const makeFileSystem = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend) => FileSystem.make({
+const make = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend) => FileSystem.make({
     access,
     chmod,
     chown,
@@ -399,8 +374,13 @@ const makeFileSystem = Effect.map(Effect.serviceOption(FileSystem.WatchBackend),
     },
     writeFile,
 }));
-export const layer = Layer.effect(FileSystem.FileSystem, makeFileSystem);
-export { Error, FileSystem, };
+export const layer = Layer.unwrapEffect(Effect
+    .gen(function* () {
+    const mod = yield* Effect.tryPromise(() => import("@effect/platform/FileSystem"));
+    return Layer.effect(mod.FileSystem, make);
+})
+    .pipe(Effect.catchAll(() => Effect.die(new globalThis.Error("@effect/platform is not installed")))));
+export { FileSystem, PlatformError as Error, };
 export function handleErrnoException(module, method) {
     return function (err, [path]) {
         let reason = "Unknown";
@@ -427,7 +407,7 @@ export function handleErrnoException(module, method) {
                 reason = "BadResource";
                 break;
         }
-        return new SystemError({
+        return new PlatformError.SystemError({
             reason,
             module,
             method,

package/dist/node/NodeFileSystem.d.ts

@@ -0,0 +1,7 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Layer from "effect/Layer";
+import * as NFS from "node:fs";
+import * as PlatformError from "../PlatformError.ts";
+export declare const layer: Layer.Layer<FileSystem.FileSystem, never, never>;
+export { FileSystem, PlatformError as Error, };
+export declare function handleErrnoException(module: PlatformError.SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError.PlatformError;