@effect/platform-node-shared 0.57.0 → 4.0.0-beta.0

package/src/NodePath.ts

@@ -1,25 +1,64 @@
 /**
  * @since 1.0.0
  */
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import { Path, TypeId } from "effect/Path"
+import { BadArgument } from "effect/PlatformError"
+import * as NodePath from "node:path"
+import * as NodeUrl from "node:url"
 
-import type { Path } from "@effect/platform/Path"
-import type { Layer } from "effect/Layer"
-import * as internal from "./internal/path.js"
+const fromFileUrl = (url: URL): Effect.Effect<string, BadArgument> =>
+  Effect.try({
+    try: () => NodeUrl.fileURLToPath(url),
+    catch: (cause) =>
+      new BadArgument({
+        module: "Path",
+        method: "fromFileUrl",
+        cause
+      })
+  })
+
+const toFileUrl = (path: string): Effect.Effect<URL, BadArgument> =>
+  Effect.try({
+    try: () => NodeUrl.pathToFileURL(path),
+    catch: (cause) =>
+      new BadArgument({
+        module: "Path",
+        method: "toFileUrl",
+        cause
+      })
+  })
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category Layers
  */
-export const layer: Layer<Path> = internal.layer
+export const layerPosix: Layer.Layer<Path> = Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath.posix,
+  fromFileUrl,
+  toFileUrl
+})
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category Layers
  */
-export const layerPosix: Layer<Path> = internal.layerPosix
+export const layerWin32: Layer.Layer<Path> = Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath.win32,
+  fromFileUrl,
+  toFileUrl
+})
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category Layers
  */
-export const layerWin32: Layer<Path> = internal.layerWin32
+export const layer: Layer.Layer<Path> = Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath,
+  fromFileUrl,
+  toFileUrl
+})

package/src/NodeRuntime.ts

@@ -1,11 +1,60 @@
 /**
  * @since 1.0.0
  */
-import type { RunMain } from "@effect/platform/Runtime"
-import * as internal from "./internal/runtime.js"
+import type { Effect } from "effect/Effect"
+import * as Runtime from "effect/Runtime"
 
 /**
  * @since 1.0.0
- * @category runtime
+ * @category Run main
  */
-export const runMain: RunMain = internal.runMain
+export const runMain: {
+  /**
+   * @since 1.0.0
+   * @category Run main
+   */
+  (
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly teardown?: Runtime.Teardown | undefined
+    }
+  ): <E, A>(effect: Effect<A, E>) => void
+  /**
+   * @since 1.0.0
+   * @category Run main
+   */
+  <E, A>(
+    effect: Effect<A, E>,
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly teardown?: Runtime.Teardown | undefined
+    }
+  ): void
+} = Runtime.makeRunMain(({
+  fiber,
+  teardown
+}) => {
+  let receivedSignal = false
+
+  fiber.addObserver((exit) => {
+    if (!receivedSignal) {
+      process.removeListener("SIGINT", onSigint)
+      process.removeListener("SIGTERM", onSigint)
+    }
+    teardown(exit, (code) => {
+      if (receivedSignal || code !== 0) {
+        process.exit(code)
+      }
+    })
+  })
+
+  function onSigint() {
+    receivedSignal = true
+    process.removeListener("SIGINT", onSigint)
+    process.removeListener("SIGTERM", onSigint)
+    fiber.interruptUnsafe(fiber.id)
+  }
+
+  process.on("SIGINT", onSigint)
+  process.on("SIGTERM", onSigint)
+})

package/src/NodeSink.ts

@@ -1,77 +1,80 @@
 /**
  * @since 1.0.0
  */
-import type { PlatformError } from "@effect/platform/Error"
-import { SystemError } from "@effect/platform/Error"
-import type { Channel } from "effect/Channel"
-import type { Chunk } from "effect/Chunk"
-import type { LazyArg } from "effect/Function"
-import type * as Sink from "effect/Sink"
-import type { Writable } from "stream"
-import * as internal from "./internal/sink.js"
-import type { FromWritableOptions } from "./NodeStream.js"
+import type { NonEmptyReadonlyArray } from "effect/Array"
+import * as Cause from "effect/Cause"
+import * as Channel from "effect/Channel"
+import * as Effect from "effect/Effect"
+import { identity, type LazyArg } from "effect/Function"
+import * as Pull from "effect/Pull"
+import * as Sink from "effect/Sink"
+import type { Writable } from "node:stream"
 
 /**
- * @category constructor
+ * @category constructors
  * @since 1.0.0
  */
-export const fromWritable: <E, A = string | Uint8Array>(
-  evaluate: LazyArg<Writable | NodeJS.WritableStream>,
-  onError: (error: unknown) => E,
-  options?: FromWritableOptions
-) => Sink.Sink<void, A, never, E> = internal.fromWritable
+export const fromWritable = <E, A = Uint8Array | string>(
+  options: {
+    readonly evaluate: LazyArg<Writable | NodeJS.WritableStream>
+    readonly onError: (error: unknown) => E
+    readonly endOnDone?: boolean | undefined
+    readonly encoding?: BufferEncoding | undefined
+  }
+): Sink.Sink<void, A, never, E> =>
+  Sink.fromChannel(Channel.mapDone(fromWritableChannel<never, E, A>(options), (_) => [_]))
 
 /**
- * @category constructor
+ * @category constructors
  * @since 1.0.0
  */
-export const fromWritableChannel: <IE, OE, A>(
-  writable: LazyArg<Writable | NodeJS.WritableStream>,
-  onError: (error: unknown) => OE,
-  options?: FromWritableOptions
-) => Channel<Chunk<never>, Chunk<A>, IE | OE, IE, void, unknown> = internal.fromWritableChannel
+export const fromWritableChannel = <IE, E, A = Uint8Array | string>(
+  options: {
+    readonly evaluate: LazyArg<Writable | NodeJS.WritableStream>
+    readonly onError: (error: unknown) => E
+    readonly endOnDone?: boolean | undefined
+    readonly encoding?: BufferEncoding | undefined
+  }
+): Channel.Channel<never, IE | E, void, NonEmptyReadonlyArray<A>, IE> =>
+  Channel.fromTransform((pull: Pull.Pull<NonEmptyReadonlyArray<A>, IE, unknown>) => {
+    const writable = options.evaluate() as Writable
+    return Effect.succeed(pullIntoWritable({ ...options, writable, pull }))
+  })
 
 /**
- * @category stdio
  * @since 1.0.0
  */
-export const stdout: Sink.Sink<void, string | Uint8Array, never, PlatformError> = fromWritable(
-  () => process.stdout,
-  (cause) =>
-    new SystemError({
-      module: "Stream",
-      method: "stdout",
-      reason: "Unknown",
-      cause
-    })
-)
-
-/**
- * @category stdio
- * @since 1.0.0
- */
-export const stderr: Sink.Sink<void, string | Uint8Array, never, PlatformError> = fromWritable(
-  () => process.stderr,
-  (cause) =>
-    new SystemError({
-      module: "Stream",
-      method: "stderr",
-      reason: "Unknown",
-      cause
-    })
-)
-
-/**
- * @category stdio
- * @since 1.0.0
- */
-export const stdin: Sink.Sink<void, string | Uint8Array, never, PlatformError> = fromWritable(
-  () => process.stdin,
-  (cause) =>
-    new SystemError({
-      module: "Stream",
-      method: "stdin",
-      reason: "Unknown",
-      cause
-    })
-)
+export const pullIntoWritable = <A, IE, E>(options: {
+  readonly pull: Pull.Pull<NonEmptyReadonlyArray<A>, IE, unknown>
+  readonly writable: Writable
+  readonly onError: (error: unknown) => E
+  readonly endOnDone?: boolean | undefined
+  readonly encoding?: BufferEncoding | undefined
+}): Pull.Pull<never, IE | E, unknown> =>
+  options.pull.pipe(
+    Effect.flatMap((chunk) => {
+      let i = 0
+      return Effect.callback<void, E>(function loop(resume) {
+        for (; i < chunk.length;) {
+          const success = options.writable.write(chunk[i++], options.encoding as any)
+          if (!success) {
+            options.writable.once("drain", () => (loop as any)(resume))
+            return
+          }
+        }
+        resume(Effect.void)
+      })
+    }),
+    Effect.forever({ disableYield: true }),
+    options.endOnDone !== false ?
+      Pull.catchDone((_) => {
+        if ("closed" in options.writable && options.writable.closed) {
+          return Cause.done(_)
+        }
+        return Effect.callback<never, E | Cause.Done<unknown>>((resume) => {
+          options.writable.once("finish", () => resume(Cause.done(_)))
+          options.writable.end()
+        })
+      }) :
+      identity
+  )

package/src/NodeSocket.ts

@@ -1,35 +1,34 @@
 /**
  * @since 1.0.0
  */
-import * as Socket from "@effect/platform/Socket"
+import type { Array } from "effect"
 import * as Channel from "effect/Channel"
-import type * as Chunk from "effect/Chunk"
-import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import type * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as FiberSet from "effect/FiberSet"
+import * as Function from "effect/Function"
 import { identity } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Scope from "effect/Scope"
+import * as ServiceMap from "effect/ServiceMap"
+import * as Socket from "effect/unstable/socket/Socket"
 import * as Net from "node:net"
 import type { Duplex } from "node:stream"
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category re-exports
  */
-export interface NetSocket {
-  readonly _: unique symbol
-}
+export * as NodeWS from "ws"
 
 /**
  * @since 1.0.0
  * @category tags
  */
-export const NetSocket: Context.Tag<NetSocket, Net.Socket> = Context.GenericTag(
+export class NetSocket extends ServiceMap.Service<NetSocket, Net.Socket>()(
   "@effect/platform-node/NodeSocket/NetSocket"
-)
+) {}
 
 /**
  * @since 1.0.0
@@ -39,13 +38,13 @@ export const makeNet = (
   options: Net.NetConnectOpts & {
     readonly openTimeout?: Duration.DurationInput | undefined
   }
-): Effect.Effect<Socket.Socket, Socket.SocketError> =>
+): Effect.Effect<Socket.Socket> =>
   fromDuplex(
-    Effect.scopeWith((scope) => {
+    Effect.servicesWith((services: ServiceMap.ServiceMap<Scope.Scope>) => {
       let conn: Net.Socket | undefined
       return Effect.flatMap(
         Scope.addFinalizer(
-          scope,
+          ServiceMap.get(services, Scope.Scope),
           Effect.sync(() => {
             if (!conn) return
             if (conn.closed === false) {
@@ -58,13 +57,17 @@ export const makeNet = (
           })
         ),
         () =>
-          Effect.async<Net.Socket, Socket.SocketError, never>((resume) => {
+          Effect.callback<Net.Socket, Socket.SocketError, never>((resume) => {
             conn = Net.createConnection(options)
             conn.once("connect", () => {
               resume(Effect.succeed(conn!))
             })
-            conn.on("error", (cause) => {
-              resume(Effect.fail(new Socket.SocketGenericError({ reason: "Open", cause })))
+            conn.on("error", (cause: Error) => {
+              resume(Effect.fail(
+                new Socket.SocketError({
+                  reason: new Socket.SocketOpenError({ kind: "Unknown", cause })
+                })
+              ))
             })
           })
       )
@@ -82,18 +85,18 @@ export const fromDuplex = <RO>(
     readonly openTimeout?: Duration.DurationInput | undefined
   }
 ): Effect.Effect<Socket.Socket, never, Exclude<RO, Scope.Scope>> =>
-  Effect.withFiberRuntime<Socket.Socket, never, Exclude<RO, Scope.Scope>>((fiber) => {
+  Effect.withFiber<Socket.Socket, never, Exclude<RO, Scope.Scope>>((fiber) => {
     let currentSocket: Duplex | undefined
-    const latch = Effect.unsafeMakeLatch(false)
-    const openContext = fiber.currentContext as Context.Context<RO>
+    const latch = Effect.makeLatchUnsafe(false)
+    const openServices = fiber.services as ServiceMap.ServiceMap<RO>
+
     const run = <R, E, _>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
       readonly onOpen?: Effect.Effect<void> | undefined
     }) =>
       Effect.scopedWith(Effect.fnUntraced(function*(scope) {
         const fiberSet = yield* FiberSet.make<any, E | Socket.SocketError>().pipe(
-          Scope.extend(scope)
+          Scope.provide(scope)
         )
-
         let conn: Duplex | undefined = undefined
         yield* Scope.addFinalizer(
           scope,
@@ -105,26 +108,30 @@ export const fromDuplex = <RO>(
             conn.off("close", onClose)
           })
         )
-
-        conn = yield* Scope.extend(open, scope).pipe(
+        conn = yield* Scope.provide(open, scope).pipe(
           options?.openTimeout ?
-            Effect.timeoutFail({
+            Effect.timeoutOrElse({
               duration: options.openTimeout,
               onTimeout: () =>
-                new Socket.SocketGenericError({ reason: "Open", cause: new Error("Connection timed out") })
+                Effect.fail(
+                  new Socket.SocketError({
+                    reason: new Socket.SocketOpenError({ kind: "Timeout", cause: new Error("Connection timed out") })
+                  })
+                )
             }) :
             identity
         )
         conn.on("end", onEnd)
         conn.on("error", onError)
         conn.on("close", onClose)
-
         const run = yield* Effect.provideService(FiberSet.runtime(fiberSet)<R>(), NetSocket, conn as Net.Socket)
         conn.on("data", onData)
 
         currentSocket = conn
-        yield* latch.open
-        if (opts?.onOpen) yield* opts.onOpen
+        latch.openUnsafe()
+        if (opts?.onOpen) {
+          yield* opts.onOpen
+        }
 
         return yield* FiberSet.join(fiberSet)
 
@@ -135,36 +142,40 @@ export const fromDuplex = <RO>(
           }
         }
         function onEnd() {
-          Deferred.unsafeDone(fiberSet.deferred, Effect.void)
+          Deferred.doneUnsafe(fiberSet.deferred, Effect.void)
         }
         function onError(cause: Error) {
-          Deferred.unsafeDone(
+          Deferred.doneUnsafe(
             fiberSet.deferred,
-            Effect.fail(new Socket.SocketGenericError({ reason: "Read", cause }))
+            Effect.fail(
+              new Socket.SocketError({
+                reason: new Socket.SocketReadError({ cause })
+              })
+            )
           )
         }
         function onClose(hadError: boolean) {
-          Deferred.unsafeDone(
+          Deferred.doneUnsafe(
             fiberSet.deferred,
             Effect.fail(
-              new Socket.SocketCloseError({
-                reason: "Close",
-                code: hadError ? 1006 : 1000
+              new Socket.SocketError({
+                reason: new Socket.SocketCloseError({ code: hadError ? 1006 : 1000 })
               })
             )
           )
         }
       })).pipe(
-        Effect.mapInputContext((input: Context.Context<R>) => Context.merge(openContext, input)),
-        Effect.ensuring(Effect.sync(() => {
-          latch.unsafeClose()
-          currentSocket = undefined
-        })),
-        Effect.interruptible
+        Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(openServices, input)),
+        Effect.onExit(() =>
+          Effect.sync(() => {
+            latch.closeUnsafe()
+            currentSocket = undefined
+          })
+        )
       )
 
     const write = (chunk: Uint8Array | string | Socket.CloseEvent) =>
-      latch.whenOpen(Effect.async<void, Socket.SocketError>((resume) => {
+      latch.whenOpen(Effect.callback<void, Socket.SocketError>((resume) => {
         const conn = currentSocket!
         if (Socket.isCloseEvent(chunk)) {
           conn.destroy(chunk.code > 1000 ? new Error(`closed with code ${chunk.code}`) : undefined)
@@ -173,7 +184,11 @@ export const fromDuplex = <RO>(
         currentSocket!.write(chunk, (cause) => {
           resume(
             cause
-              ? Effect.fail(new Socket.SocketGenericError({ reason: "Write", cause }))
+              ? Effect.fail(
+                new Socket.SocketError({
+                  reason: new Socket.SocketWriteError({ cause: cause! })
+                })
+              )
               : Effect.void
           )
         })
@@ -203,14 +218,13 @@ export const fromDuplex = <RO>(
 export const makeNetChannel = <IE = never>(
   options: Net.NetConnectOpts
 ): Channel.Channel<
-  Chunk.Chunk<Uint8Array>,
-  Chunk.Chunk<Uint8Array | string | Socket.CloseEvent>,
+  Array.NonEmptyReadonlyArray<Uint8Array>,
   Socket.SocketError | IE,
-  IE,
   void,
-  unknown
+  Array.NonEmptyReadonlyArray<Uint8Array | string | Socket.CloseEvent>,
+  IE
 > =>
-  Channel.unwrapScoped(
+  Channel.unwrap(
     Effect.map(makeNet(options), Socket.toChannelWith<IE>())
   )
 
@@ -218,5 +232,7 @@ export const makeNetChannel = <IE = never>(
  * @since 1.0.0
  * @category layers
  */
-export const layerNet = (options: Net.NetConnectOpts): Layer.Layer<Socket.Socket, Socket.SocketError> =>
-  Layer.effect(Socket.Socket, makeNet(options))
+export const layerNet: (options: Net.NetConnectOpts) => Layer.Layer<
+  Socket.Socket,
+  Socket.SocketError
+> = Function.flow(makeNet, Layer.effect(Socket.Socket))