effect-start 0.23.0 → 0.25.0

package/dist/Start.js

@@ -1,15 +1,20 @@
-import * as Context from "effect/Context";
-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 BunRuntime from "./bun/BunRuntime.js";
-import * as BunServer from "./bun/BunServer.js";
-import * as NodeFileSystem from "./node/NodeFileSystem.js";
-import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.js";
-export function layer(...layers) {
-    return Layer.mergeAll(...layers);
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as BunRuntime from "./bun/BunRuntime.js"
+import * as BunServer from "./bun/BunServer.js"
+import * as NodeFileSystem from "./node/NodeFileSystem.js"
+import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.js"
+import * as StartApp from "./StartApp.js"
+
+export function layer(
+  ...layers
+) {
+  return Layer.mergeAll(...layers)
 }
+
 /**
  * Bundles layers together, wiring their dependencies automatically.
  *
@@ -31,19 +36,44 @@ export function layer(...layers) {
  * @since 1.0.0
  * @category constructors
  */
-export function pack(...layers) {
-    const layerArray = layers;
-    const result = layerArray.reduce((acc, layer) => Layer.provideMerge(acc, layer), Layer.succeedContext(Context.empty()));
-    return result;
+export function pack(
+  ...layers
+) {
+  const layerArray = layers
+  const result = layerArray.reduce(
+    (acc, layer) => Layer.provideMerge(acc, layer),
+    Layer.succeedContext(Context.empty()),
+  )
+
+  return result
 }
-export function serve(load) {
-    const appLayer = Function.pipe(Effect.tryPromise(load), Effect.map((v) => v.default), Effect.orDie, Layer.unwrapEffect);
-    const serverLayer = Layer.scoped(BunServer.BunServer, Effect.gen(function* () {
-        const existing = yield* Effect.serviceOption(BunServer.BunServer);
-        if (Option.isSome(existing))
-            return existing.value;
-        return yield* BunServer.make({});
-    }));
-    const composed = Function.pipe(serverLayer, BunServer.withLogAddress, Layer.provide(appLayer), Layer.provide(NodeFileSystem.layer), Layer.provide(BunChildProcessSpawner.layer));
-    return Function.pipe(composed, Layer.launch, BunRuntime.runMain);
+
+export const Live = Layer.mergeAll(
+  NodeFileSystem.layer,
+  BunChildProcessSpawner.layer,
+  Layer.effect(
+    StartApp.StartApp,
+    Deferred.make().pipe(Effect.map((server) => ({ server }))),
+  ),
+)
+
+export function serve(
+  load,
+) {
+  const appLayer = Function.pipe(
+    Effect.tryPromise(load),
+    Effect.map((v) => v.default),
+    Effect.orDie,
+    Layer.unwrapEffect,
+  )
+
+  const appLayerResolved = Function.pipe(appLayer, Layer.provideMerge(Live))
+
+  const composed = Function.pipe(
+    BunServer.layerStart(),
+    BunServer.withLogAddress,
+    Layer.provide(appLayerResolved),
+  )
+
+  return Function.pipe(composed, Layer.launch, BunRuntime.runMain)
 }

package/dist/StartApp.js

@@ -1,21 +1,3 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as PubSub from "effect/PubSub";
-import * as Ref from "effect/Ref";
-export class StartApp extends Context.Tag("effect-start/StartApp")() {
-}
-export function layer(options) {
-    return Layer.effect(StartApp, Effect.gen(function* () {
-        const env = options?.env ?? process.env.NODE_ENV ?? "development";
-        const middleware = yield* Ref.make(Function.identity);
-        const events = yield* PubSub.unbounded();
-        return StartApp.of({
-            env,
-            middleware,
-            addMiddleware: (f) => Ref.update(middleware, (prev) => (app) => f(prev(app))),
-            events,
-        });
-    }));
-}
+import * as Context from "effect/Context"
+
+export class StartApp extends Context.Tag("effect-start/StartApp")() {}

package/dist/StreamExtra.js

@@ -1,11 +1,14 @@
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import * as Function from "effect/Function";
-import * as Predicate from "effect/Predicate";
-import * as Runtime from "effect/Runtime";
-import * as Stream from "effect/Stream";
-export const isStream = (u) => Predicate.hasProperty(u, Stream.StreamTypeId);
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Function from "effect/Function"
+import * as Predicate from "effect/Predicate"
+import * as Runtime from "effect/Runtime"
+import * as Stream from "effect/Stream"
+
+export const isStream = (u) =>
+  Predicate.hasProperty(u, Stream.StreamTypeId)
+
 /**
  * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to
  * fix an issue in Bun when native stream controller stops working when request
@@ -17,84 +20,116 @@ export const isStream = (u) => Predicate.hasProperty(u, Stream.StreamTypeId);
  * https://github.com/Effect-TS/effect/issues/4538
  * https://github.com/oven-sh/bun/issues/17837
  */
-export const toReadableStreamRuntimePatched = Function.dual((args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
-    const runFork = Runtime.runFork(runtime);
-    let currentResolve = undefined;
-    let fiber = undefined;
-    const latch = Effect.unsafeMakeLatch(false);
-    return new ReadableStream({
+export const toReadableStreamRuntimePatched = Function.dual(
+  (args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]),
+  (
+    self,
+    runtime,
+    options,
+  ) => {
+    const runFork = Runtime.runFork(runtime)
+    let currentResolve = undefined
+    let fiber = undefined
+    const latch = Effect.unsafeMakeLatch(false)
+
+    return new ReadableStream(
+      {
         start(controller) {
-            fiber = runFork(Stream.runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
-                latch.unsafeClose();
-                try {
+          fiber = runFork(
+            Stream.runForEachChunk(self, (chunk) =>
+              latch.whenOpen(
+                Effect.sync(() => {
+                  latch.unsafeClose()
+                  try {
                     for (const item of chunk) {
-                        controller.enqueue(item);
+                      controller.enqueue(item)
                     }
-                }
-                catch (e) {
-                    if (e.message ===
-                        `Value of "this" must be of type ReadableStreamDefaultController`) {
-                        // Do nothing when this happens in Bun.
+                  } catch (e) {
+                    if (
+                      (e).message ===
+                      `Value of "this" must be of type ReadableStreamDefaultController`
+                    ) {
+                      // Do nothing when this happens in Bun.
+                    } else {
+                      throw e
                     }
-                    else {
-                        throw e;
-                    }
-                }
-                currentResolve();
-                currentResolve = undefined;
-            }))));
-            // --- CHANGES HERE ---
-            // In original code, we had fiber.addObserver here that called
-            // error() or close() on controller. This patched version removes it.
+                  }
+                  currentResolve()
+                  currentResolve = undefined
+                }),
+              ),
+            ),
+          )
+          // --- CHANGES HERE ---
+          // In original code, we had fiber.addObserver here that called
+          // error() or close() on controller. This patched version removes it.
         },
         pull() {
-            return new Promise((resolve) => {
-                currentResolve = resolve;
-                Effect.runSync(latch.open);
-            });
+          return new Promise((resolve) => {
+            currentResolve = resolve
+            Effect.runSync(latch.open)
+          })
         },
         cancel() {
-            if (!fiber)
-                return;
-            return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)));
+          if (!fiber) return
+          return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)))
         },
-    }, options?.strategy);
-});
-export const toReadableStreamRuntimePatched2 = Function.dual((args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]), (self, runtime, options) => {
-    const runSync = Runtime.runSync(runtime);
-    const runFork = Runtime.runFork(runtime);
-    let currentResolve = undefined;
-    let fiber = undefined;
-    const latch = Effect.unsafeMakeLatch(false);
-    return new ReadableStream({
+      },
+      options?.strategy,
+    )
+  },
+)
+
+export const toReadableStreamRuntimePatched2 = Function.dual(
+  (args) => Predicate.hasProperty(args[0], Stream.StreamTypeId) || Effect.isEffect(args[0]),
+  (
+    self,
+    runtime,
+    options,
+  ) => {
+    const runSync = Runtime.runSync(runtime)
+    const runFork = Runtime.runFork(runtime)
+    let currentResolve = undefined
+    let fiber = undefined
+    const latch = Effect.unsafeMakeLatch(false)
+
+    return new ReadableStream(
+      {
         start(controller) {
-            fiber = runFork(Stream.runForEachChunk(self, (chunk) => latch.whenOpen(Effect.sync(() => {
-                latch.unsafeClose();
-                for (const item of chunk) {
-                    controller.enqueue(item);
-                }
-                currentResolve();
-                currentResolve = undefined;
-            }))));
-            fiber.addObserver((exit) => {
-                if (exit._tag === "Failure") {
-                    controller.error(Cause.squash(exit.cause));
-                }
-                else {
-                    controller.close();
-                }
-            });
+          fiber = runFork(
+            Stream.runForEachChunk(self, (chunk) =>
+              latch.whenOpen(
+                Effect.sync(() => {
+                  latch.unsafeClose()
+                  for (const item of chunk) {
+                    controller.enqueue(item)
+                  }
+                  currentResolve()
+                  currentResolve = undefined
+                }),
+              ),
+            ),
+          )
+          fiber.addObserver((exit) => {
+            if (exit._tag === "Failure") {
+              controller.error(Cause.squash(exit.cause))
+            } else {
+              controller.close()
+            }
+          })
         },
         pull() {
-            return new Promise((resolve) => {
-                currentResolve = resolve;
-                Effect.runSync(latch.open);
-            });
+          return new Promise((resolve) => {
+            currentResolve = resolve
+            Effect.runSync(latch.open)
+          })
         },
         cancel() {
-            if (!fiber)
-                return;
-            return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)));
+          if (!fiber) return
+          return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)))
         },
-    }, options?.strategy);
-});
+      },
+      options?.strategy,
+    )
+  },
+)

package/dist/System.js

@@ -1,22 +1,38 @@
-import * as Effect from "effect/Effect";
-import * as ChildProcess from "./ChildProcess.js";
-import * as PlatformError from "./PlatformError.js";
-export const cwd = Effect.sync(() => process.cwd());
-export const which = (name) => Effect.flatMap(Effect.try({
-    try: () => Bun.which(name),
-    catch: (err) => new PlatformError.SystemError({
-        reason: "Unknown",
-        module: "System",
-        method: "which",
-        description: err instanceof Error ? err.message : `Failed to look up "${name}"`,
-        cause: err,
+import * as Effect from "effect/Effect"
+
+import * as ChildProcess from "./ChildProcess.js"
+import * as PlatformError from "./PlatformError.js"
+
+export const cwd = Effect.sync(() => process.cwd())
+
+export const which = (name) =>
+  Effect.flatMap(
+    Effect.try({
+      try: () => Bun.which(name),
+      catch: (err) =>
+        new PlatformError.SystemError({
+          reason: "Unknown",
+          module: "System",
+          method: "which",
+          description: err instanceof Error ? err.message : `Failed to look up "${name}"`,
+          cause: err,
+        }),
     }),
-}), (path) => path === null
-    ? Effect.fail(new PlatformError.SystemError({
-        reason: "NotFound",
-        module: "System",
-        method: "which",
-        description: `Executable not found: "${name}"`,
-    }))
-    : Effect.succeed(path));
-export const spawn = (command, args, options) => ChildProcess.spawn(ChildProcess.make(command, args, options));
+    (path) =>
+      path === null
+        ? Effect.fail(
+            new PlatformError.SystemError({
+              reason: "NotFound",
+              module: "System",
+              method: "which",
+              description: `Executable not found: "${name}"`,
+            }),
+          )
+        : Effect.succeed(path),
+  )
+
+export const spawn = (
+  command,
+  args,
+  options,
+) => ChildProcess.spawn(ChildProcess.make(command, args, options))

package/dist/TuplePathPattern.js

@@ -1,68 +1,74 @@
+
 export function format(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "[[" + el[0][0] + "]]";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + "[" + name + "]" + (suffix ?? "");
-        })
-            .join("/"));
+  return ("/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "[[" + el[0][0] + "]]"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + "[" + name + "]" + (suffix ?? "")
+      })
+      .join("/"))
 }
+
 export function toColon(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "*";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + ":" + name + (suffix ?? "");
-        })
-            .join("/"));
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "*"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + ":" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
-export const toHono = toColon;
+
+export const toHono = toColon
+
 export function toExpress(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "*" + el[0][0];
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + ":" + name + (suffix ?? "");
-        })
-            .join("/"));
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "*" + el[0][0]
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + ":" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
-export const toEffect = toColon;
+
+export const toEffect = toColon
+
 export function toURLPattern(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return ":" + el[0][0] + "+";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + ":" + name + (suffix ?? "");
-        })
-            .join("/"));
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return ":" + el[0][0] + "+"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + ":" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
+
 export function toRemix(tuple) {
-    return ("/" +
-        tuple
-            .map((el) => {
-            if (typeof el === "string")
-                return el;
-            if (Array.isArray(el[0]))
-                return "$";
-            const [name, suffix, prefix] = el;
-            return (prefix ?? "") + "$" + name + (suffix ?? "");
-        })
-            .join("/"));
+  return (
+    "/" +
+    tuple
+      .map((el) => {
+        if (typeof el === "string") return el
+        if (Array.isArray(el[0])) return "$"
+        const [name, suffix, prefix] = el
+        return (prefix ?? "") + "$" + name + (suffix ?? "")
+      })
+      .join("/")
+  )
 }
-export const toBun = toColon;
+
+export const toBun = toColon