effect-start 0.17.0 → 0.17.2

package/dist/node/FileSystem.js

@@ -0,0 +1,440 @@
+/*
+ * 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 Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import * as Crypto 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({
+    module: "FileSystem",
+    method,
+    cause,
+});
+// == access
+const access = (() => {
+    const nodeAccess = 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);
+    };
+})();
+// == copy
+const copy = (() => {
+    const nodeCp = 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"));
+    return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
+})();
+// == chmod
+const chmod = (() => {
+    const nodeChmod = 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"));
+    return (path, uid, gid) => nodeChown(path, uid, gid);
+})();
+// == link
+const link = (() => {
+    const nodeLink = 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"));
+    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));
+    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");
+// == remove
+const removeFactory = (method) => {
+    const nodeRm = 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 open = openFactory("open");
+const makeFile = (() => {
+    const nodeReadFactory = (method) => 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 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 Error.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);
+})();
+// == 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 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) => {
+            if (err) {
+                resume(Effect.fail(handleErrnoException("FileSystem", "readFile")(err, [path])));
+            }
+            else {
+                resume(Effect.succeed(data));
+            }
+        });
+    }
+    catch (err) {
+        resume(Effect.fail(handleBadArgument("readFile")(err)));
+    }
+});
+// == readLink
+const readLink = (() => {
+    const nodeReadLink = 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"));
+    return (path) => nodeRealPath(path);
+})();
+// == rename
+const rename = (() => {
+    const nodeRename = effectify(NFS.rename, handleErrnoException("FileSystem", "rename"), handleBadArgument("rename"));
+    return (oldPath, newPath) => nodeRename(oldPath, newPath);
+})();
+// == stat
+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(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"));
+    return (target, path) => nodeSymlink(target, path);
+})();
+// == truncate
+const truncate = (() => {
+    const nodeTruncate = 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"));
+    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)
+            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 Error.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);
+// == writeFile
+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 makeFileSystem = 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, makeFileSystem);
+export { Error, FileSystem, };
+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 SystemError({
+            reason,
+            module,
+            method,
+            pathOrDescriptor: path,
+            syscall: err.syscall,
+            description: err.message,
+            cause: err,
+        });
+    };
+}

package/dist/node/Utils.d.ts

@@ -0,0 +1 @@
+export declare const findClosestPackageJson: (path: string) => Promise<string | undefined>;

package/dist/node/Utils.js

@@ -0,0 +1,19 @@
+import * as NFS from "node:fs/promises";
+import * as NPath from "node:path";
+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/repro_fail.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/repro_fail.js

@@ -0,0 +1,14 @@
+import { Context } from "effect";
+import * as Route from "./RouteBody";
+const ServiceA = Context.GenericTag("ServiceA");
+const ServiceB = Context.GenericTag("ServiceB");
+// This handler requires BOTH ServiceA and ServiceB.
+// In the original type definition, Generator requires all yields to have the same R.
+// ServiceA != ServiceB, so this should fail type checking.
+const handler = Route.handle(function* () {
+    yield* ServiceA;
+    yield* ServiceB;
+    return "ok";
+});
+// To avoid unused variable warning
+console.log(handler);

package/dist/testing/TestHttpClient.d.ts

@@ -0,0 +1,13 @@
+import * as HttpApp from "@effect/platform/HttpApp";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import { RouteNotFound } from "@effect/platform/HttpServerError";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as Effect from "effect/Effect";
+export type FetchHandler = (req: Request) => Response | Promise<Response>;
+export declare const isFetchHandler: (app: unknown) => app is FetchHandler;
+export declare const make: <E, R>(appOrHandler: HttpApp.Default<E, R> | FetchHandler, opts?: {
+    baseUrl?: string | null;
+    handleRouteNotFound?: (e: RouteNotFound) => Effect.Effect<HttpClientResponse.HttpClientResponse> | null;
+}) => HttpClient.HttpClient.With<HttpClientError.HttpClientError | E, Exclude<R, HttpServerRequest.HttpServerRequest>>;

package/dist/testing/TestHttpClient.js

@@ -0,0 +1,68 @@
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import { RouteNotFound } from "@effect/platform/HttpServerError";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as UrlParams from "@effect/platform/UrlParams";
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
+import * as Function from "effect/Function";
+import * as Stream from "effect/Stream";
+const WebHeaders = globalThis.Headers;
+export const isFetchHandler = (app) => typeof app === "function" && !Effect.isEffect(app);
+const fromFetchHandler = (handler) => Effect.gen(function* () {
+    const serverRequest = yield* HttpServerRequest.HttpServerRequest;
+    const webRequest = serverRequest.source;
+    const response = yield* Effect.promise(async () => handler(webRequest));
+    const body = yield* Effect.promise(() => response.arrayBuffer());
+    return HttpServerResponse.raw(new Uint8Array(body), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+    });
+});
+export const make = (appOrHandler, opts) => {
+    const httpApp = isFetchHandler(appOrHandler)
+        ? fromFetchHandler(appOrHandler)
+        : appOrHandler;
+    const execute = (request) => {
+        const urlResult = UrlParams.makeUrl(request.url, request.urlParams, request.hash);
+        if (Either.isLeft(urlResult)) {
+            return Effect.die(urlResult.left);
+        }
+        const url = urlResult.right;
+        const controller = new AbortController();
+        const signal = controller.signal;
+        const send = (body) => {
+            const serverRequest = HttpServerRequest.fromWeb(new Request(url.toString(), {
+                method: request.method,
+                headers: new WebHeaders(request.headers),
+                body,
+                duplex: request.body._tag === "Stream" ? "half" : undefined,
+                signal,
+            }));
+            return Function.pipe(httpApp, Effect.provideService(HttpServerRequest.HttpServerRequest, serverRequest), Effect.andThen(HttpServerResponse.toWeb), Effect.andThen(res => HttpClientResponse.fromWeb(request, res)), opts?.handleRouteNotFound === null
+                ? Function.identity
+                : Effect.catchAll((e) => e instanceof RouteNotFound
+                    ? Effect.succeed(HttpClientResponse.fromWeb(request, new Response("Failed with RouteNotFound", {
+                        status: 404,
+                    })))
+                    : Effect.fail(e)));
+        };
+        switch (request.body._tag) {
+            case "Raw":
+            case "Uint8Array":
+                return send(request.body.body);
+            case "FormData":
+                return send(request.body.formData);
+            case "Stream":
+                return Effect.flatMap(Stream.toReadableStreamEffect(request.body.stream), send);
+        }
+        return send(undefined);
+    };
+    const client = HttpClient.makeWith((requestEffect) => Effect.flatMap(requestEffect, execute), (request) => Effect.succeed(request));
+    return client.pipe(opts?.baseUrl === null
+        ? Function.identity
+        : HttpClient.mapRequest(HttpClientRequest.prependUrl(opts?.baseUrl ?? "http://localhost")));
+};

package/dist/testing/TestLogger.d.ts

@@ -0,0 +1,13 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
+export type TestLoggerContext = {
+    messages: Ref.Ref<Array<string>>;
+};
+declare const TestLogger_base: Context.TagClass<TestLogger, "effect-start/TestLogger", TestLoggerContext>;
+export declare class TestLogger extends TestLogger_base {
+}
+export declare function layer(): Layer.Layer<TestLogger>;
+export declare const messages: Effect.Effect<Array<string>, never, TestLogger>;
+export {};

package/dist/testing/TestLogger.js

@@ -0,0 +1,29 @@
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FiberRef from "effect/FiberRef";
+import * as HashSet from "effect/HashSet";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as MutableRef from "effect/MutableRef";
+import * as Ref from "effect/Ref";
+export class TestLogger extends Context.Tag("effect-start/TestLogger")() {
+}
+export function layer() {
+    return Layer.effect(TestLogger, Effect.gen(function* () {
+        const messages = yield* Ref.make([]);
+        const mutableRef = messages.ref;
+        const customLogger = Logger.make(({ message, logLevel, cause }) => {
+            const causeStr = !Cause.isEmpty(cause)
+                ? ` ${Cause.pretty(cause)}`
+                : "";
+            MutableRef.update(mutableRef, (msgs) => [...msgs, `[${logLevel._tag}] ${String(message)}${causeStr}`]);
+        });
+        yield* FiberRef.update(FiberRef.currentLoggers, (loggers) => HashSet.add(HashSet.remove(loggers, Logger.defaultLogger), customLogger));
+        return { messages };
+    }));
+}
+export const messages = Effect.gen(function* () {
+    const logger = yield* TestLogger;
+    return yield* Ref.get(logger.messages);
+});

package/dist/testing/index.d.ts

@@ -0,0 +1,3 @@
+export * as TestHttpClient from "./TestHttpClient.ts";
+export * as TestLogger from "./TestLogger.ts";
+export * from "./utils.ts";

package/dist/testing/index.js

@@ -0,0 +1,3 @@
+export * as TestHttpClient from "./TestHttpClient.js";
+export * as TestLogger from "./TestLogger.js";
+export * from "./utils.js";

package/dist/testing/utils.d.ts

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import type { YieldWrap } from "effect/Utils";
+/**
+ * Creates a scoped Effects and runs is asynchronously.
+ * Useful for testing.
+ */
+export declare const effectFn: <RL>(layer?: Layer.Layer<RL, any>) => <Eff extends YieldWrap<Effect.Effect<any, any, RE>>, AEff, RE extends RL | Scope.Scope>(f: () => Generator<Eff, AEff, never>) => Promise<void>;

package/dist/testing/utils.js

@@ -0,0 +1,39 @@
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+/**
+ * Creates a scoped Effects and runs is asynchronously.
+ * Useful for testing.
+ */
+export const effectFn = (layer) => (f) => Function.pipe(Effect.gen(f), Effect.scoped, Effect.provide(Logger.pretty), Effect.provide(layer ?? Layer.empty), 
+// @ts-expect-error will have to figure out how to clear deps
+Effect.runPromise, v => v.then(() => { }, clearStackTraces));
+/*
+ * When effect fails, instead of throwing FiberFailure,
+ * throw a plain Error with the strack trace and hides
+ * effect internals.
+ * Otherwise, at least on Bun, the strack trace is repeated,
+ * with some junks in between taking half of the screen.
+ *
+ * Direct children that starts with a dot are excluded because
+ * some tools, like effect-start, use it to generate temporary
+ * files that are then loaded into a runtime.
+ */
+const clearStackTraces = (err) => {
+    const ExternalStackTraceLineRegexp = /\(.*\/node_modules\/[^\.]/;
+    const message = err instanceof Error
+        ? err.message
+        : typeof err === "object" && err !== null && "message" in err
+            ? String(err.message)
+            : String(err);
+    const stack = err instanceof Error
+        ? err.stack ?? ""
+        : typeof err === "object" && err !== null && "stack" in err
+            ? String(err.stack)
+            : "";
+    const newErr = new Error(message);
+    newErr.stack = Function.pipe(stack.split("\n"), Array.takeWhile(s => !ExternalStackTraceLineRegexp.test(s)), Array.join("\n"));
+    throw newErr;
+};